Debian Codegraph @

modules/lsp-runtime-lib/src/main/runtime/LSPString.cpp

raw
1 /*
2 * Copyright (C) 2024 Linux Studio Plugins Project <https://lsp-plug.in/>
3 * (C) 2024 Vladimir Sadovnikov <[email protected]>
4 *
5 * This file is part of lsp-runtime-lib
6 * Created on: 30 авг. 2017 г.
7 *
8 * lsp-runtime-lib is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * any later version.
12 *
13 * lsp-runtime-lib is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with lsp-runtime-lib. If not, see <https://www.gnu.org/licenses/>.
20 */
21
22 #include <lsp-plug.in/common/types.h>
23 #include <lsp-plug.in/common/status.h>
24 #include <lsp-plug.in/common/alloc.h>
25 #include <lsp-plug.in/stdlib/stdio.h>
26 #include <lsp-plug.in/stdlib/string.h>
27 #include <lsp-plug.in/io/charset.h>
28 #include <lsp-plug.in/runtime/LSPString.h>
29
30 #include <stdarg.h>
31 #include <stdlib.h>
32 #include <errno.h>
33 #include <wctype.h>
34
35 #define GRANULARITY 0x20
36 #define BUF_SIZE 0x200
37 //#define BUF_SIZE 16
38
39 #define XSAFE_TRANS(index, length, result) \
40 if (index < 0) \
41 { \
42 if ((index += (length)) < 0) \
43 return result; \
44 } \
45 else if (size_t(index) > (length)) \
46 return result;
47
48 #define XSAFE_ITRANS(index, length, result) \
49 if (index < 0) \
50 { \
51 if ((index += (length)) < 0) \
52 return result; \
53 } \
54 else if (size_t(index) >= (length)) \
55 return result;
56
57 namespace lsp
58 {
59 static bool is_space(lsp_wchar_t c)
60 {
61 switch (c)
62 {
63 case ' ':
64 case '\t':
65 case '\n':
66 case '\r':
67 case '\v':
68 return true;
69 default:
70 return false;
71 }
72 }
73
74 LSPString::LSPString()
75 {
76 nLength = 0;
77 nCapacity = 0;
78 pData = NULL;
79 nHash = 0;
80 pTemp = NULL;
81 }
82
83 LSPString::~LSPString()
84 {
85 truncate();
86 }
87
88 #ifndef ARCH_LE
89 int LSPString::xcmp(const lsp_wchar_t *a, const lsp_wchar_t *b, size_t n)
90 {
91 while (n--)
92 {
93 int32_t retval = int32_t(*(a++)) - int32_t(*(b++));
94 if (retval != 0)
95 return (retval > 0) ? 1 : -1;
96 }
97 return 0;
98 }
99 #endif /* ARCH_LE */
100
101 inline size_t LSPString::xlen(const lsp_wchar_t *s)
102 {
103 size_t i=0;
104 while (s[i] != 0)
105 ++i;
106 return i;
107 }
108
109 inline size_t LSPString::u16len(const lsp_utf16_t *s)
110 {
111 size_t i=0;
112 while (s[i] != 0)
113 ++i;
114 return i;
115 }
116
117 int LSPString::xcasecmp(const lsp_wchar_t *a, const lsp_wchar_t *b, size_t n)
118 {
119 while (n--)
120 {
121 int32_t retval = int32_t(lsp::to_lower(*(a++))) - int32_t(lsp::to_lower(*(b++)));
122 if (retval != 0)
123 return (retval > 0) ? 1 : -1;
124 }
125 return 0;
126 }
127
128 void LSPString::acopy(lsp_wchar_t *dst, const char *src, size_t n)
129 {
130 while (n--)
131 *(dst++) = uint8_t(*(src++));
132 }
133
134 void LSPString::drop_temp()
135 {
136 if (pTemp == NULL)
137 return;
138
139 if (pTemp->pData != NULL)
140 ::free(pTemp->pData);
141
142 ::free(pTemp);
143 pTemp = NULL;
144 }
145
146 void LSPString::clear()
147 {
148 drop_temp();
149 nLength = 0;
150 nHash = 0;
151 }
152
153 void LSPString::truncate()
154 {
155 drop_temp();
156
157 nLength = 0;
158 nHash = 0;
159 nCapacity = 0;
160 if (pData == NULL)
161 return;
162
163 xfree(pData);
164 pData = NULL;
165 }
166
167 bool LSPString::truncate(size_t size)
168 {
169 drop_temp();
170 if (size > nCapacity)
171 return true;
172 if (nLength > size)
173 {
174 nHash = 0;
175 nLength = size;
176 }
177
178 lsp_wchar_t *v = xrealloc(pData, size);
179 if ((v == NULL) && (size > 0))
180 return false;
181
182 pData = (size > 0) ? v : NULL;
183 nCapacity = size;
184 return true;
185 }
186
187 size_t LSPString::set_length(size_t length)
188 {
189 if (nLength <= length)
190 return length;
191
192 drop_temp();
193 nHash = 0;
194 return nLength = length;
195 }
196
197 size_t LSPString::range_length(ssize_t first, ssize_t last) const
198 {
199 XSAFE_TRANS(first, nLength, 0);
200 XSAFE_TRANS(last, nLength, 0);
201 return (first < last) ? last - first : 0;
202 }
203
204 bool LSPString::size_reserve(size_t size)
205 {
206 if (size > 0)
207 {
208 lsp_wchar_t *v = xrealloc(pData, size);
209 if (v == NULL)
210 return false;
211 pData = v;
212 }
213 else if (pData != NULL)
214 {
215 ::free(pData);
216 pData = NULL;
217 }
218
219 nCapacity = size;
220 return true;
221 }
222
223 inline bool LSPString::cap_reserve(size_t size)
224 {
225 size_t ncap = (size + (GRANULARITY-1)) & (~(GRANULARITY-1));
226 return (ncap > nCapacity) ? size_reserve(ncap) : true;
227 }
228
229 inline bool LSPString::cap_grow(size_t delta)
230 {
231 size_t avail = nCapacity - nLength;
232 if (delta <= avail)
233 return true;
234 avail = nCapacity >> 1;
235 if (avail < delta)
236 avail = delta;
237 return size_reserve(nCapacity + ((avail + (GRANULARITY-1)) & (~(GRANULARITY-1))));
238 }
239
240 void LSPString::reduce()
241 {
242 drop_temp();
243 if (nCapacity <= nLength)
244 return;
245 lsp_wchar_t *v = xrealloc(pData, nLength);
246 if ((v == NULL) && (nLength > 0))
247 return;
248 pData = (nLength > 0) ? v : NULL;
249 nCapacity = nLength;
250 }
251
252 void LSPString::trim()
253 {
254 if ((pData == NULL) || (nLength <= 0))
255 return;
256
257 // Cut tail first
258 lsp_wchar_t *p = &pData[nLength];
259 while (nLength > 0)
260 {
261 if (!is_space(*(--p)))
262 break;
263 nLength--;
264 nHash = 0;
265 }
266 if (nLength <= 0)
267 return;
268
269 // Cut head
270 p = pData;
271 while (true)
272 {
273 if (!is_space(*p))
274 break;
275 p++;
276 }
277 if (p > pData)
278 {
279 nHash = 0;
280 nLength -= (p - pData);
281 }
282 if (nLength <= 0)
283 return;
284
285 xmove(pData, p, nLength);
286 }
287
288 void LSPString::swap(LSPString *src)
289 {
290 if (src == this)
291 return;
292
293 size_t len = src->nLength;
294 size_t cap = src->nCapacity;
295 lsp_wchar_t *c = src->pData;
296 size_t hash = src->nHash;
297
298 src->nLength = nLength;
299 src->nCapacity = nCapacity;
300 src->pData = pData;
301 src->nHash = nHash;
302
303 nLength = len;
304 nCapacity = cap;
305 pData = c;
306 nHash = hash;
307 }
308
309 bool LSPString::swap(ssize_t idx1, ssize_t idx2)
310 {
311 XSAFE_ITRANS(idx1, nLength, false);
312 XSAFE_ITRANS(idx2, nLength, false);
313 if (idx1 == idx2)
314 return true;
315
316 // Swap characters
317 nHash = 0;
318 lsp_wchar_t c = pData[idx1];
319 pData[idx1] = pData[idx2];
320 pData[idx2] = c;
321
322 return true;
323 }
324
325 void LSPString::take(LSPString *src)
326 {
327 drop_temp();
328 if (pData != NULL)
329 xfree(pData);
330
331 nLength = src->nLength;
332 nCapacity = src->nCapacity;
333 pData = src->pData;
334 nHash = src->nHash;
335
336 src->nLength = 0;
337 src->nCapacity = 0;
338 src->pData = NULL;
339 src->nHash = 0;
340 }
341
342 void LSPString::take(LSPString &src)
343 {
344 drop_temp();
345 if (pData != NULL)
346 xfree(pData);
347
348 nLength = src.nLength;
349 nCapacity = src.nCapacity;
350 pData = src.pData;
351 nHash = src.nHash;
352
353 src.nLength = 0;
354 src.nCapacity = 0;
355 src.pData = NULL;
356 src.nHash = 0;
357 }
358
359 LSPString *LSPString::copy() const
360 {
361 LSPString *s = new LSPString();
362 if (s == NULL)
363 return s;
364
365 s->nLength = nLength;
366 s->nCapacity = nLength;
367 if (s->nLength > 0)
368 {
369 s->pData = xmalloc(nLength);
370 if (s->pData == NULL)
371 {
372 delete s;
373 return NULL;
374 }
375
376 xmove(s->pData, pData, nLength);
377 }
378 else
379 s->pData = NULL;
380
381 return s;
382 }
383
384 LSPString *LSPString::release()
385 {
386 LSPString *str = new LSPString();
387 if (str != NULL)
388 str->swap(this);
389 return str;
390 }
391
392 LSPString *LSPString::copy(ssize_t first) const
393 {
394 LSPString *s = new LSPString();
395 if (s != NULL)
396 {
397 if (!s->set(this, first))
398 {
399 delete s;
400 s = NULL;
401 }
402 }
403
404 return s;
405 }
406
407 LSPString *LSPString::copy(ssize_t first, ssize_t last) const
408 {
409 LSPString *s = new LSPString();
410 if (s != NULL)
411 {
412 if (!s->set(this, first, last))
413 {
414 delete s;
415 s = NULL;
416 }
417 }
418
419 return s;
420 }
421
422 lsp_wchar_t LSPString::at(ssize_t index) const
423 {
424 if (index < 0)
425 {
426 if ((index += nLength) < 0)
427 return 0;
428 }
429 else if (size_t(index) >= nLength)
430 return 0;
431
432 return pData[index];
433 }
434
435 lsp_wchar_t LSPString::first() const
436 {
437 return (nLength > 0) ? pData[0] : 0;
438 }
439
440 lsp_wchar_t LSPString::last() const
441 {
442 return (nLength > 0) ? pData[nLength-1] : 0;
443 }
444
445 bool LSPString::set(lsp_wchar_t ch)
446 {
447 drop_temp();
448
449 if (nCapacity == 0)
450 {
451 lsp_wchar_t *v = xmalloc(GRANULARITY);
452 if (v == NULL)
453 return false;
454 v[0] = ch;
455 pData = v;
456 nCapacity = GRANULARITY;
457 }
458 else
459 pData[0] = ch;
460
461 nHash = 0;
462 nLength = 1;
463 return true;
464 }
465
466 bool LSPString::set(const lsp_wchar_t *arr)
467 {
468 return set(arr, xlen(arr));
469 }
470
471 bool LSPString::set(const lsp_wchar_t *arr, size_t n)
472 {
473 drop_temp();
474
475 if (!cap_reserve(n))
476 return false;
477
478 xmove(pData, arr, n);
479 nHash = 0;
480 nLength = n;
481 return true;
482 }
483
484 bool LSPString::set(ssize_t first, lsp_wchar_t ch)
485 {
486 XSAFE_ITRANS(first, nLength, false);
487 pData[first] = ch;
488 nHash = 0;
489 return true;
490 }
491
492 bool LSPString::set(const LSPString *src)
493 {
494 if (src == this)
495 return true;
496 drop_temp();
497
498 if (!cap_reserve(src->nLength))
499 return false;
500 if (src->nLength > 0)
501 xmove(pData, src->pData, src->nLength);
502 nLength = src->nLength;
503 nHash = 0;
504 return true;
505 }
506
507 bool LSPString::set(const LSPString *src, ssize_t first)
508 {
509 drop_temp();
510
511 XSAFE_TRANS(first, src->nLength, false);
512 ssize_t length = src->nLength - first;
513
514 if (length > 0)
515 {
516 if (!cap_reserve(length))
517 return false;
518 xmove(pData, &src->pData[first], length);
519 nLength = length;
520 }
521 else
522 nLength = 0;
523
524 nHash = 0;
525 return true;
526 }
527
528 bool LSPString::set(const LSPString *src, ssize_t first, ssize_t last)
529 {
530 drop_temp();
531
532 XSAFE_TRANS(first, src->nLength, false);
533 XSAFE_TRANS(last, src->nLength, false);
534
535 ssize_t length = last - first;
536 if (length > 0)
537 {
538 if (!cap_reserve(length))
539 return false;
540 xmove(pData, &src->pData[first], length);
541 nLength = length;
542 }
543 else
544 nLength = 0;
545
546 nHash = 0;
547 return true;
548 }
549
550 bool LSPString::insert(ssize_t pos, lsp_wchar_t ch)
551 {
552 XSAFE_TRANS(pos, nLength, false);
553
554 if (!cap_grow(1))
555 return false;
556
557 ssize_t length = nLength - pos;
558 if (length > 0)
559 xmove(&pData[pos+1], &pData[pos], length);
560
561 pData[pos] = ch;
562 nLength++;
563 nHash = 0;
564 return true;
565 }
566
567 bool LSPString::insert(ssize_t pos, const lsp_wchar_t *arr, ssize_t n)
568 {
569 XSAFE_TRANS(pos, nLength, false);
570 if (!cap_grow(n))
571 return false;
572
573 ssize_t count = nLength - pos;
574 if (count > 0)
575 xmove(&pData[pos+n], &pData[pos], count);
576 xmove(&pData[pos], arr, n);
577 nLength += n;
578 nHash = 0;
579 return true;
580 }
581
582 bool LSPString::insert(ssize_t pos, const LSPString *src)
583 {
584 if (src->nLength <= 0)
585 return true;
586
587 XSAFE_TRANS(pos, nLength, false);
588 if (!cap_grow(src->nLength))
589 return false;
590
591 ssize_t count = nLength - pos;
592 if (count > 0)
593 xmove(&pData[pos+src->nLength], &pData[pos], count);
594 xmove(&pData[pos], src->pData, src->nLength);
595 nLength += src->nLength;
596 nHash = 0;
597 return true;
598 }
599
600 bool LSPString::insert(ssize_t pos, const LSPString *src, ssize_t first)
601 {
602 XSAFE_TRANS(first, src->nLength, false);
603 ssize_t length = src->nLength - first;
604 if (length <= 0)
605 return true;
606
607 XSAFE_TRANS(pos, nLength, false);
608 if (!cap_grow(length))
609 return false;
610
611 ssize_t count = nLength - pos;
612 if (count > 0)
613 xmove(&pData[pos+length], &pData[pos], count);
614 xmove(&pData[pos], &src->pData[first], length);
615 nLength += length;
616 nHash = 0;
617 return true;
618 }
619
620 bool LSPString::insert(ssize_t pos, const LSPString *src, ssize_t first, ssize_t last)
621 {
622 XSAFE_TRANS(first, src->nLength, false);
623 XSAFE_TRANS(last, src->nLength, false);
624 ssize_t length = last - first;
625 if (length <= 0)
626 return true;
627
628 XSAFE_TRANS(pos, nLength, false);
629 if (!cap_grow(length))
630 return false;
631
632 ssize_t count = nLength - pos;
633 if (count > 0)
634 xmove(&pData[pos+length], &pData[pos], count);
635 xmove(&pData[pos], &src->pData[first], length);
636 nLength += length;
637 nHash = 0;
638 return true;
639 }
640
641 bool LSPString::append(char ch)
642 {
643 if (!cap_grow(1))
644 return false;
645 pData[nLength++] = uint8_t(ch);
646 nHash = 0;
647 return true;
648 }
649
650 bool LSPString::append(lsp_wchar_t ch)
651 {
652 if (!cap_grow(1))
653 return false;
654 pData[nLength++] = ch;
655 nHash = 0;
656 return true;
657 }
658
659 bool LSPString::append(lsp_swchar_t ch)
660 {
661 if (!cap_grow(1))
662 return false;
663 pData[nLength++] = ch;
664 nHash = 0;
665 return true;
666 }
667
668 bool LSPString::append(const lsp_wchar_t *arr)
669 {
670 return append(arr, xlen(arr));
671 }
672
673 bool LSPString::append(const lsp_wchar_t *arr, size_t n)
674 {
675 if (!cap_grow(n))
676 return false;
677 xmove(&pData[nLength], arr, n);
678 nLength += n;
679 nHash = 0;
680 return true;
681 }
682
683 bool LSPString::append_ascii(const char *arr, size_t n)
684 {
685 if (!cap_grow(n))
686 return false;
687 acopy(&pData[nLength], arr, n);
688 nLength += n;
689 nHash = 0;
690 return true;
691 }
692
693 bool LSPString::append_utf8(const char *arr, size_t n)
694 {
695 if (nLength <= 0)
696 return set_utf8(arr, n);
697
698 LSPString tmp;
699 if (!tmp.set_utf8(arr, n))
700 return false;
701 return append(&tmp);
702 }
703
704 bool LSPString::append_utf16(const lsp_utf16_t *arr, size_t n)
705 {
706 if (nLength <= 0)
707 return set_utf16(arr, n);
708
709 LSPString tmp;
710 if (!tmp.set_utf16(arr, n))
711 return false;
712 return append(&tmp);
713 }
714
715 bool LSPString::append_utf16(const lsp_utf16_t *arr)
716 {
717 return append_utf16(arr, u16len(arr));
718 }
719
720 bool LSPString::append(const LSPString *src)
721 {
722 if (src->nLength <= 0)
723 return true;
724 if (!cap_grow(src->nLength))
725 return false;
726 xmove(&pData[nLength], src->pData, src->nLength);
727 nLength += src->nLength;
728 nHash = 0;
729 return true;
730 }
731
732 bool LSPString::append(const LSPString *src, ssize_t first)
733 {
734 XSAFE_TRANS(first, src->nLength, false);
735 ssize_t length = src->nLength - first;
736 if (length <= 0)
737 return true;
738
739 if (!cap_grow(length))
740 return false;
741 xmove(&pData[nLength], &src->pData[first], length);
742 nLength += length;
743 nHash = 0;
744 return true;
745 }
746
747 bool LSPString::append(const LSPString *src, ssize_t first, ssize_t last)
748 {
749 XSAFE_TRANS(first, src->nLength, false);
750 XSAFE_TRANS(last, src->nLength, false);
751 ssize_t length = last - first;
752 if (length <= 0)
753 return true;
754
755 if (!cap_grow(length))
756 return false;
757 xmove(&pData[nLength], &src->pData[first], length);
758 nLength += length;
759 nHash = 0;
760 return true;
761 }
762
763 bool LSPString::prepend(lsp_wchar_t ch)
764 {
765 if (!cap_grow(1))
766 return false;
767 if (nLength > 0)
768 xmove(&pData[1], pData, nLength);
769 pData[0] = ch;
770 nLength ++;
771 nHash = 0;
772 return true;
773 }
774
775 bool LSPString::prepend(const lsp_wchar_t *arr, size_t n)
776 {
777 if (n <= 0)
778 return true;
779 if (!cap_grow(n))
780 return false;
781
782 if (nLength > 0)
783 xmove(&pData[n], pData, nLength);
784 xmove(pData, arr, n);
785 nLength += n;
786 nHash = 0;
787 return true;
788 }
789
790 bool LSPString::prepend_ascii(const char *arr, size_t n)
791 {
792 if (n <= 0)
793 return true;
794 if (!cap_grow(n))
795 return false;
796
797 if (nLength > 0)
798 xmove(&pData[n], pData, nLength);
799 acopy(pData, arr, n);
800 nLength += n;
801 nHash = 0;
802 return true;
803 }
804
805 bool LSPString::prepend_utf8(const char *arr, size_t n)
806 {
807 if (nLength <= 0)
808 return set_utf8(arr, n);
809
810 LSPString tmp;
811 if (!tmp.set_utf8(arr, n))
812 return false;
813 return prepend(&tmp);
814 }
815
816 bool LSPString::prepend(const LSPString *src)
817 {
818 if (src->nLength <= 0)
819 return true;
820 if (!cap_grow(src->nLength))
821 return false;
822
823 if (nLength > 0)
824 xmove(&pData[src->nLength], pData, nLength);
825 xmove(pData, src->pData, src->nLength);
826 nLength += src->nLength;
827 nHash = 0;
828 return true;
829 }
830
831 bool LSPString::prepend(const LSPString *src, ssize_t first)
832 {
833 XSAFE_TRANS(first, src->nLength, false);
834 ssize_t length = src->nLength - first;
835 if (length <= 0)
836 return true;
837
838 if (!cap_grow(length))
839 return false;
840 if (nLength > 0)
841 xmove(&pData[length], pData, nLength);
842 xmove(pData, &src->pData[first], length);
843 nLength += length;
844 nHash = 0;
845 return true;
846 }
847
848 bool LSPString::prepend(const LSPString *src, ssize_t first, ssize_t last)
849 {
850 XSAFE_TRANS(first, src->nLength, false);
851 XSAFE_TRANS(last, src->nLength, false);
852 ssize_t length = last - first;
853 if (length <= 0)
854 return true;
855
856 if (!cap_grow(length))
857 return false;
858 if (nLength > 0)
859 xmove(&pData[length], pData, nLength);
860 xmove(pData, &src->pData[first], length);
861 nLength += length;
862 nHash = 0;
863 return true;
864 }
865
866 bool LSPString::ends_with(lsp_wchar_t ch) const
867 {
868 return (nLength > 0) ? pData[nLength-1] == ch : false;
869 }
870
871 bool LSPString::ends_with_nocase(lsp_wchar_t ch) const
872 {
873 if (nLength <= 0)
874 return false;
875 return lsp::to_lower(pData[nLength-1]) == lsp::to_lower(ch);
876 }
877
878 bool LSPString::ends_with(const LSPString *src) const
879 {
880 if (src->nLength <= 0)
881 return true;
882
883 ssize_t offset = nLength - src->nLength;
884 if (offset < 0)
885 return false;
886
887 return xcmp(&pData[offset], src->pData, src->nLength) == 0;
888 }
889
890 bool LSPString::ends_with_ascii(const char *src) const
891 {
892 size_t len = strlen(src);
893 return (len <= nLength) ? starts_with_ascii(src, nLength - len) : false;
894 }
895
896 bool LSPString::ends_with_ascii_nocase(const char *src) const
897 {
898 size_t len = strlen(src);
899 return (len <= nLength) ? starts_with_ascii_nocase(src, nLength - len) : false;
900 }
901
902 bool LSPString::ends_with_nocase(const LSPString *src) const
903 {
904 if (src->nLength <= 0)
905 return true;
906
907 ssize_t offset = nLength - src->nLength;
908 if (offset < 0)
909 return false;
910
911 return xcasecmp(&pData[offset], src->pData, src->nLength) == 0;
912 }
913
914 bool LSPString::starts_with(lsp_wchar_t ch, size_t offset) const
915 {
916 return (offset < nLength) ? pData[offset] == ch : false;
917 }
918
919 bool LSPString::starts_with_nocase(lsp_wchar_t ch, size_t offset) const
920 {
921 if (offset > nLength)
922 return false;
923 return lsp::to_lower(pData[offset]) == lsp::to_lower(ch);
924 }
925
926 bool LSPString::starts_with(const LSPString *src, size_t offset) const
927 {
928 if (src->nLength <= 0)
929 return true;
930
931 if (nLength < (src->nLength + offset))
932 return false;
933
934 return xcmp(&pData[offset], src->pData, src->nLength) == 0;
935 }
936
937 bool LSPString::starts_with_ascii(const char *str, size_t offset) const
938 {
939 if (offset > nLength)
940 return false;
941
942 for (size_t i=offset, n=nLength; (i < n); ++i)
943 {
944 lsp_wchar_t c = uint8_t(*(str++));
945 if (c == 0)
946 return true;
947 else if (c != pData[i])
948 return false;
949 }
950 return (*str == '\0');
951 }
952
953 bool LSPString::starts_with_nocase(const LSPString *src, size_t offset) const
954 {
955 if (src->nLength <= 0)
956 return true;
957
958 if (nLength < (offset + src->nLength))
959 return false;
960
961 return xcasecmp(&pData[offset], src->pData, src->nLength) == 0;
962 }
963
964 bool LSPString::starts_with_ascii_nocase(const char *str, size_t offset) const
965 {
966 if (offset > nLength)
967 return false;
968
969 for (size_t i=offset, n=nLength; (i < n); ++i)
970 {
971 lsp_wchar_t c = uint8_t(*(str++));
972 if (c == 0)
973 return true;
974 else if (lsp::to_lower(c) != lsp::to_lower(pData[i]))
975 return false;
976 }
977 return (*str == '\0');
978 }
979
980 bool LSPString::remove()
981 {
982 drop_temp();
983 nLength = 0;
984 nHash = 0;
985 return true;
986 }
987
988 bool LSPString::remove(ssize_t first)
989 {
990 XSAFE_TRANS(first, nLength, false);
991 nLength = first;
992 nHash = 0;
993 return true;
994 }
995
996 bool LSPString::remove(ssize_t first, ssize_t last)
997 {
998 XSAFE_TRANS(first, nLength, false);
999 XSAFE_TRANS(last, nLength, false);
1000 ssize_t length = last - first;
1001 if (length <= 0)
1002 return true;
1003
1004 ssize_t count = nLength - last;
1005 if (count > 0)
1006 xmove(&pData[first], &pData[last], count);
1007
1008 nLength -= length;
1009 nHash = 0;
1010 return true;
1011 }
1012
1013 bool LSPString::remove_last()
1014 {
1015 if (nLength <= 0)
1016 return false;
1017 --nLength;
1018 nHash = 0;
1019 return true;
1020 }
1021
1022 void LSPString::reverse()
1023 {
1024 drop_temp();
1025 nHash = 0;
1026
1027 size_t n = (nLength >> 1);
1028 lsp_wchar_t *h = pData, *t = &pData[nLength];
1029 while (n--)
1030 {
1031 lsp_wchar_t c = *h;
1032 *(h++) = *(--t);
1033 *t = c;
1034 }
1035 }
1036
1037 void LSPString::shuffle()
1038 {
1039 if (nLength < 2)
1040 return;
1041
1042 nHash = 0;
1043 size_t n = nLength * 2;
1044 size_t idx1 = rand() % nLength, idx2;
1045
1046 while (n--)
1047 {
1048 // Generate random indexes
1049 idx1 = (idx1 + rand()) % nLength;
1050 idx2 = (idx1 + rand()) % nLength;
1051 if (idx1 == idx2)
1052 continue;
1053
1054 // Swap characters
1055 lsp_wchar_t c = pData[idx1];
1056 pData[idx1] = pData[idx2];
1057 pData[idx2] = c;
1058 }
1059 }
1060
1061 bool LSPString::replace(ssize_t pos, lsp_wchar_t ch)
1062 {
1063 XSAFE_TRANS(pos, nLength, false);
1064
1065 if (size_t(pos) < nLength)
1066 {
1067 pData[pos] = ch;
1068 nLength = pos;
1069 nHash = 0;
1070
1071 return true;
1072 }
1073
1074 // Append at the tail
1075 return append(ch);
1076 }
1077
1078 bool LSPString::replace(ssize_t pos, const lsp_wchar_t *arr, size_t n)
1079 {
1080 XSAFE_TRANS(pos, nLength, false);
1081
1082 if (!cap_reserve(pos + n))
1083 return false;
1084
1085 xmove(&pData[pos], arr, n);
1086 nLength = pos + n;
1087 nHash = 0;
1088 return true;
1089 }
1090
1091 bool LSPString::replace(ssize_t pos, const LSPString *src)
1092 {
1093 XSAFE_TRANS(pos, nLength, false);
1094
1095 if (!cap_reserve(pos + src->nLength))
1096 return false;
1097
1098 xmove(&pData[pos], src->pData, src->nLength);
1099 nLength = pos + src->nLength;
1100 nHash = 0;
1101 return true;
1102 }
1103
1104 bool LSPString::replace(ssize_t pos, const LSPString *src, ssize_t first)
1105 {
1106 XSAFE_TRANS(pos, nLength, false);
1107 XSAFE_TRANS(first, src->nLength, false);
1108 ssize_t length = src->nLength - first;
1109
1110 if (length > 0)
1111 {
1112 if (!cap_reserve(pos + length))
1113 return false;
1114
1115 xmove(&pData[pos], &src->pData[first], length);
1116 }
1117 nLength = pos + length;
1118 nHash = 0;
1119 return true;
1120 }
1121
1122 bool LSPString::replace(ssize_t pos, const LSPString *src, ssize_t first, ssize_t last)
1123 {
1124 XSAFE_TRANS(pos, nLength, false);
1125 XSAFE_TRANS(first, src->nLength, false);
1126 XSAFE_TRANS(last, src->nLength, false);
1127 ssize_t length = lsp_max(last - first, 0);
1128
1129 if (length > 0)
1130 {
1131 if (!cap_reserve(pos + length))
1132 return false;
1133
1134 xmove(&pData[pos], &src->pData[first], length);
1135 }
1136
1137 nLength = pos + length;
1138 nHash = 0;
1139 return true;
1140 }
1141
1142 bool LSPString::replace(ssize_t first, ssize_t last, lsp_wchar_t ch)
1143 {
1144 XSAFE_TRANS(first, nLength, false);
1145 XSAFE_TRANS(last, nLength, false);
1146 ssize_t count = last - first;
1147 if (count < 0)
1148 count = 0;
1149
1150 if (!cap_reserve(nLength - count + 1))
1151 return false;
1152
1153 ssize_t tail = nLength - first - count;
1154 if (tail > 0)
1155 xmove(&pData[first + 1], &pData[tail], nLength - tail);
1156 pData[first] = ch;
1157
1158 nLength = nLength - count + 1;
1159 nHash = 0;
1160 return true;
1161 }
1162
1163 bool LSPString::replace(ssize_t first, ssize_t last, const lsp_wchar_t *arr, size_t n)
1164 {
1165 XSAFE_TRANS(first, nLength, false);
1166 XSAFE_TRANS(last, nLength, false);
1167 ssize_t count = lsp_max(last - first, 0);
1168
1169 if (!cap_reserve(nLength - count + n))
1170 return false;
1171
1172 ssize_t tail = nLength - first - count;
1173 if (tail > 0)
1174 xmove(&pData[first + n], &pData[tail], nLength - tail);
1175 if (n > 0)
1176 xmove(&pData[first], arr, n);
1177 nLength = nLength - count + n;
1178 nHash = 0;
1179 return true;
1180 }
1181
1182 bool LSPString::replace(ssize_t first, ssize_t last, const LSPString *src)
1183 {
1184 XSAFE_TRANS(first, nLength, false);
1185 XSAFE_TRANS(last, nLength, false);
1186 ssize_t count = lsp_max(last - first, 0);
1187
1188 if (!cap_reserve(nLength - count + src->nLength))
1189 return false;
1190
1191 ssize_t tail = nLength - first - count;
1192 if (tail > 0)
1193 xmove(&pData[first + src->nLength], &pData[tail], nLength - tail);
1194 if (src->nLength > 0)
1195 xmove(&pData[first], src->pData, src->nLength);
1196 nLength = nLength - count + src->nLength;
1197 nHash = 0;
1198 return true;
1199 }
1200
1201 bool LSPString::replace(ssize_t first, ssize_t last, const LSPString *src, ssize_t sfirst)
1202 {
1203 XSAFE_TRANS(first, nLength, false);
1204 XSAFE_TRANS(last, nLength, false);
1205 ssize_t count = last - first;
1206 if (count < 0)
1207 count = 0;
1208
1209 XSAFE_TRANS(sfirst, src->nLength, false);
1210 ssize_t scount = src->nLength - sfirst;
1211
1212 if (!cap_reserve(nLength - count + scount))
1213 return false;
1214
1215 ssize_t tail = nLength - first - count;
1216 if (tail > 0)
1217 xmove(&pData[first + scount], &pData[tail], nLength - tail);
1218 if (scount > 0)
1219 xmove(&pData[first], &src->pData[sfirst], scount);
1220
1221 nLength = nLength - count + scount;
1222 nHash = 0;
1223 return true;
1224 }
1225
1226 bool LSPString::replace(ssize_t first, ssize_t last, const LSPString *src, ssize_t sfirst, ssize_t slast)
1227 {
1228 XSAFE_TRANS(first, nLength, false);
1229 XSAFE_TRANS(last, nLength, false);
1230 ssize_t count = lsp_max(last - first, 0);
1231
1232 XSAFE_TRANS(sfirst, src->nLength, false);
1233 XSAFE_TRANS(slast, src->nLength, false);
1234 ssize_t scount = lsp_max(slast - sfirst, 0);
1235
1236 if (!cap_reserve(nLength - count + scount))
1237 return false;
1238
1239 ssize_t tail = nLength - first - count;
1240 if (tail > 0)
1241 xmove(&pData[first + scount], &pData[tail], nLength - tail);
1242 if (scount > 0)
1243 xmove(&pData[first], &src->pData[sfirst], scount);
1244
1245 nLength = nLength - count + scount;
1246 nHash = 0;
1247 return true;
1248 }
1249
1250 size_t LSPString::replace_all(lsp_wchar_t ch, lsp_wchar_t rep)
1251 {
1252 size_t n = 0;
1253 for (size_t i=0; i<nLength; ++i)
1254 {
1255 if (pData[i] == ch)
1256 {
1257 pData[i] = rep;
1258 ++n;
1259 }
1260 }
1261 if (n > 0)
1262 nHash = 0;
1263
1264 return n;
1265 }
1266
1267 ssize_t LSPString::index_of(ssize_t start, const LSPString *str) const
1268 {
1269 XSAFE_TRANS(start, nLength, -1);
1270 if (str->nLength <= 0)
1271 return start;
1272
1273 ssize_t last = nLength - str->nLength;
1274 while (start <= last)
1275 {
1276 if (xcmp(&pData[start], str->pData, str->nLength) == 0)
1277 return start;
1278 start ++;
1279 }
1280 return -1;
1281 }
1282
1283 ssize_t LSPString::index_of(const LSPString *str) const
1284 {
1285 if (str->nLength <= 0)
1286 return 0;
1287
1288 ssize_t start = 0, last = nLength - str->nLength;
1289 while (start <= last)
1290 {
1291 if (xcmp(&pData[start], str->pData, str->nLength) == 0)
1292 return start;
1293 start ++;
1294 }
1295 return -1;
1296 }
1297
1298 ssize_t LSPString::index_of(ssize_t start, lsp_wchar_t ch) const
1299 {
1300 XSAFE_TRANS(start, nLength, -1);
1301
1302 ssize_t length = nLength;
1303 while (start < length)
1304 {
1305 if (pData[start] == ch)
1306 return start;
1307 start ++;
1308 }
1309
1310 return -1;
1311 }
1312
1313 ssize_t LSPString::index_of(lsp_wchar_t ch) const
1314 {
1315 for (size_t start = 0; start < nLength; ++start)
1316 {
1317 if (pData[start] == ch)
1318 return start;
1319 }
1320 return -1;
1321 }
1322
1323 ssize_t LSPString::rindex_of(ssize_t start, const LSPString *str) const
1324 {
1325 if (start > ssize_t(nLength))
1326 return -1;
1327
1328 start -= str->nLength;
1329 while (start >= 0)
1330 {
1331 if (xcmp(&pData[start], str->pData, str->nLength) == 0)
1332 return start;
1333 start --;
1334 }
1335 return -1;
1336 }
1337
1338 ssize_t LSPString::rindex_of(const LSPString *str) const
1339 {
1340 if (str->nLength <= 0)
1341 return 0;
1342
1343 ssize_t start = nLength - str->nLength;
1344 while (start >= 0)
1345 {
1346 if (xcmp(&pData[start], str->pData, str->nLength) == 0)
1347 return start;
1348 start --;
1349 }
1350 return -1;
1351 }
1352
1353 ssize_t LSPString::rindex_of(ssize_t start, lsp_wchar_t ch) const
1354 {
1355 XSAFE_ITRANS(start, nLength, -1);
1356
1357 while (start >= 0)
1358 {
1359 if (pData[start] == ch)
1360 return start;
1361 start --;
1362 }
1363
1364 return -1;
1365 }
1366
1367 ssize_t LSPString::rindex_of(lsp_wchar_t ch) const
1368 {
1369 for (ssize_t start=nLength-1; start >= 0; --start)
1370 {
1371 if (pData[start] == ch)
1372 return start;
1373 }
1374 return -1;
1375 }
1376
1377 ssize_t LSPString::index_of_nocase(ssize_t start, const LSPString *str) const
1378 {
1379 XSAFE_TRANS(start, nLength, -1);
1380 if (str->nLength <= 0)
1381 return start;
1382
1383 ssize_t last = nLength - str->nLength;
1384 while (start <= last)
1385 {
1386 if (xcasecmp(&pData[start], str->pData, str->nLength) == 0)
1387 return start;
1388 start ++;
1389 }
1390 return -1;
1391 }
1392
1393 ssize_t LSPString::index_of_nocase(const LSPString *str) const
1394 {
1395 if (str->nLength <= 0)
1396 return 0;
1397
1398 ssize_t start = 0, last = nLength - str->nLength;
1399 while (start <= last)
1400 {
1401 if (xcasecmp(&pData[start], str->pData, str->nLength) == 0)
1402 return start;
1403 start ++;
1404 }
1405 return -1;
1406 }
1407
1408 ssize_t LSPString::index_of_nocase(ssize_t start, lsp_wchar_t ch) const
1409 {
1410 XSAFE_TRANS(start, nLength, -1);
1411
1412 ssize_t length = nLength;
1413 ch = lsp::to_lower(ch);
1414 while (start < length)
1415 {
1416 if (lsp::to_lower(pData[start]) == ch)
1417 return start;
1418 start ++;
1419 }
1420
1421 return -1;
1422 }
1423
1424 ssize_t LSPString::index_of_nocase(lsp_wchar_t ch) const
1425 {
1426 ch = lsp::to_lower(ch);
1427 for (size_t start = 0; start < nLength; ++start)
1428 {
1429 if (lsp::to_lower(pData[start]) == ch)
1430 return start;
1431 }
1432 return -1;
1433 }
1434
1435 ssize_t LSPString::rindex_of_nocase(ssize_t start, const LSPString *str) const
1436 {
1437 if (start > ssize_t(nLength))
1438 return -1;
1439
1440 start -= str->nLength;
1441 while (start >= 0)
1442 {
1443 if (xcasecmp(&pData[start], str->pData, str->nLength) == 0)
1444 return start;
1445 start --;
1446 }
1447 return -1;
1448 }
1449
1450 ssize_t LSPString::rindex_of_nocase(const LSPString *str) const
1451 {
1452 if (str->nLength <= 0)
1453 return 0;
1454
1455 ssize_t start = nLength - str->nLength;
1456 while (start >= 0)
1457 {
1458 if (xcasecmp(&pData[start], str->pData, str->nLength) == 0)
1459 return start;
1460 start --;
1461 }
1462 return -1;
1463 }
1464
1465 ssize_t LSPString::rindex_of_nocase(ssize_t start, lsp_wchar_t ch) const
1466 {
1467 XSAFE_ITRANS(start, nLength, -1);
1468
1469 ch = lsp::to_lower(ch);
1470 while (start >= 0)
1471 {
1472 if (lsp::to_lower(pData[start]) == ch)
1473 return start;
1474 start --;
1475 }
1476
1477 return -1;
1478 }
1479
1480 ssize_t LSPString::rindex_of_nocase(lsp_wchar_t ch) const
1481 {
1482 ch = lsp::to_lower(ch);
1483 for (ssize_t start=nLength-1; start >= 0; --start)
1484 {
1485 if (lsp::to_lower(pData[start]) == ch)
1486 return start;
1487 }
1488 return -1;
1489 }
1490
1491 LSPString *LSPString::substring(ssize_t first) const
1492 {
1493 XSAFE_TRANS(first, nLength, NULL);
1494 ssize_t length = nLength - first;
1495
1496 LSPString *s = new LSPString();
1497 if (s == NULL)
1498 return s;
1499
1500 s->nLength = length;
1501 s->nCapacity = length;
1502
1503 if (length > 0)
1504 {
1505 s->pData = xmalloc(length);
1506 if (s->pData == NULL)
1507 {
1508 delete s;
1509 return NULL;
1510 }
1511
1512 xmove(s->pData, &pData[first], length);
1513 }
1514 else
1515 s->pData = NULL;
1516
1517 return s;
1518 }
1519
1520 LSPString *LSPString::substring(ssize_t first, ssize_t last) const
1521 {
1522 XSAFE_TRANS(first, nLength, NULL);
1523 XSAFE_TRANS(last, nLength, NULL);
1524 ssize_t length = last - first;
1525 if (length < 0)
1526 length = 0;
1527
1528 LSPString *s = new LSPString();
1529 if (s == NULL)
1530 return s;
1531
1532 s->nLength = length;
1533 s->nCapacity = length;
1534
1535 if (length > 0)
1536 {
1537 s->pData = xmalloc(length);
1538 if (s->pData == NULL)
1539 {
1540 delete s;
1541 return NULL;
1542 }
1543
1544 xmove(s->pData, &pData[first], length);
1545 }
1546 else
1547 s->pData = NULL;
1548
1549 return s;
1550 }
1551
1552 int LSPString::compare_to(const lsp_wchar_t *src) const
1553 {
1554 return compare_to(src, xlen(src));
1555 }
1556
1557 int LSPString::compare_to(const lsp_wchar_t *src, size_t len) const
1558 {
1559 ssize_t n = (nLength > len) ? len : nLength;
1560 const lsp_wchar_t *a = pData, *b = src;
1561
1562 while (n--)
1563 {
1564 int retval = int(*(a++)) - int(*(b++));
1565 if (retval != 0)
1566 return retval;
1567 }
1568
1569 if (a < &pData[nLength])
1570 return int(*a);
1571 else if (b < &src[len])
1572 return -int(*b);
1573
1574 return 0;
1575 }
1576
1577 int LSPString::compare_to_ascii(const char *src) const
1578 {
1579 size_t i=0;
1580 for ( ; i<nLength; ++i)
1581 {
1582 if (src[i] == '\0')
1583 return pData[i];
1584 int retval = int(pData[i]) - uint8_t(src[i]);
1585 if (retval != 0)
1586 return retval;
1587 }
1588 return -int(uint8_t(src[i]));
1589 }
1590
1591 int LSPString::compare_to_utf8(const char *src) const
1592 {
1593 LSPString tmp;
1594 return (tmp.set_utf8(src)) ? compare_to(&tmp) : 0;
1595 }
1596
1597 int LSPString::compare_to_utf16(const lsp_utf16_t *src) const
1598 {
1599 LSPString tmp;
1600 return (tmp.set_utf16(src)) ? compare_to(&tmp) : 0;
1601 }
1602
1603 int LSPString::compare_to_ascii_nocase(const char *src) const
1604 {
1605 size_t i=0;
1606 for ( ; i<nLength; ++i)
1607 {
1608 if (src[i] == '\0')
1609 return pData[i];
1610 int retval = int(::lsp::to_lower(pData[i])) - ::lsp::to_lower(uint8_t(src[i]));
1611 if (retval != 0)
1612 return retval;
1613 }
1614 return -int(uint8_t(src[i]));
1615 }
1616
1617 int LSPString::compare_to_nocase(const lsp_wchar_t *src, size_t len) const
1618 {
1619 ssize_t n = (nLength > len) ? len : nLength;
1620 const lsp_wchar_t *a = pData, *b = src;
1621
1622 while (n--)
1623 {
1624 int retval = int(::lsp::to_lower(*(a++))) - int(::lsp::to_lower(*(b++)));
1625 if (retval != 0)
1626 return retval;
1627 }
1628
1629 if (a < &pData[nLength])
1630 return int(*a);
1631 else if (b < &src[len])
1632 return -int(*b);
1633
1634 return 0;
1635 }
1636
1637 int LSPString::compare_to_nocase(const lsp_wchar_t *src) const
1638 {
1639 return compare_to_nocase(src, xlen(src));
1640 }
1641
1642 int LSPString::compare_to_utf8_nocase(const char *src) const
1643 {
1644 LSPString tmp;
1645 return (tmp.set_utf8(src)) ? compare_to_nocase(&tmp) : 0;
1646 }
1647
1648 int LSPString::compare_to_utf16_nocase(const lsp_utf16_t *src) const
1649 {
1650 LSPString tmp;
1651 return (tmp.set_utf16(src)) ? compare_to_nocase(&tmp) : 0;
1652 }
1653
1654 size_t LSPString::tolower()
1655 {
1656 for (size_t i=0; i<nLength; ++i)
1657 pData[i] = lsp::to_lower(pData[i]);
1658 nHash = 0;
1659 return nLength;
1660 }
1661
1662 size_t LSPString::tolower(ssize_t first)
1663 {
1664 XSAFE_TRANS(first, nLength, 0);
1665 ssize_t n = nLength - first;
1666 if (n <= 0)
1667 return 0;
1668
1669 lsp_wchar_t *ptr = &pData[first];
1670 for (ssize_t i=0; i<n; ++i)
1671 ptr[i] = lsp::to_lower(ptr[i]);
1672
1673 nHash = 0;
1674 return n;
1675 }
1676
1677 size_t LSPString::tolower(ssize_t first, ssize_t last)
1678 {
1679 XSAFE_TRANS(first, nLength, 0);
1680 XSAFE_TRANS(last, nLength, 0);
1681 if (last < first)
1682 {
1683 ssize_t tmp = last;
1684 last = first;
1685 first = tmp;
1686 }
1687
1688 ssize_t n = last - first;
1689 lsp_wchar_t *ptr = &pData[first];
1690 for (; first < last; ++first)
1691 ptr[first] = lsp::to_lower(ptr[first]);
1692 nHash = 0;
1693 return n;
1694 }
1695
1696 size_t LSPString::toupper()
1697 {
1698 for (size_t i=0; i<nLength; ++i)
1699 pData[i] = lsp::to_upper(pData[i]);
1700 nHash = 0;
1701 return nLength;
1702 }
1703
1704 size_t LSPString::toupper(ssize_t first)
1705 {
1706 XSAFE_TRANS(first, nLength, 0);
1707 ssize_t n = nLength - first;
1708 if (n <= 0)
1709 return 0;
1710
1711 lsp_wchar_t *ptr = &pData[first];
1712 for (ssize_t i=0; i<n; ++i)
1713 ptr[i] = lsp::to_upper(ptr[i]);
1714 nHash = 0;
1715 return n;
1716 }
1717
1718 size_t LSPString::toupper(ssize_t first, ssize_t last)
1719 {
1720 XSAFE_TRANS(first, nLength, 0);
1721 XSAFE_TRANS(last, nLength, 0);
1722 if (last < first)
1723 {
1724 ssize_t tmp = last;
1725 last = first;
1726 first = tmp;
1727 }
1728 ssize_t n = last - first;
1729 lsp_wchar_t *ptr = &pData[first];
1730 for (; first < last; ++first)
1731 ptr[first] = lsp::to_upper(ptr[first]);
1732 nHash = 0;
1733 return n;
1734 }
1735
1736 bool LSPString::equals(const lsp_wchar_t *src, size_t len) const
1737 {
1738 if (nLength != len)
1739 return false;
1740 if (nLength <= 0)
1741 return true;
1742
1743 return xcmp(pData, src, nLength) == 0;
1744 }
1745
1746 bool LSPString::equals(const lsp_wchar_t *src) const
1747 {
1748 return equals(src, xlen(src));
1749 }
1750
1751 bool LSPString::equals(const LSPString *src, ssize_t first, ssize_t last) const
1752 {
1753 XSAFE_TRANS(first, src->nLength, false);
1754 XSAFE_TRANS(last, src->nLength, false);
1755
1756 return equals(&src->pData[first], last - first);
1757 }
1758
1759 bool LSPString::equals_nocase(const lsp_wchar_t *src, size_t len) const
1760 {
1761 if (nLength != len)
1762 return false;
1763
1764 const lsp_wchar_t *a = pData, *b = src;
1765 for (size_t i=nLength; i>0; --i)
1766 {
1767 if (lsp::to_lower(*(a++)) != lsp::to_lower(*(b++)))
1768 return false;
1769 }
1770
1771 return true;
1772 }
1773
1774 bool LSPString::equals_nocase(const lsp_wchar_t *src) const
1775 {
1776 return equals_nocase(src, xlen(src));
1777 }
1778
1779 bool LSPString::contains_at(ssize_t index, const lsp_wchar_t *src) const
1780 {
1781 const lsp_wchar_t *p = &pData[index];
1782 while (*src != '\0')
1783 {
1784 if (size_t(++index) > nLength)
1785 return false;
1786 if (*(p++) != *(src++))
1787 return false;
1788 }
1789
1790 return true;
1791 }
1792
1793 bool LSPString::contains_at(ssize_t index, const lsp_wchar_t *src, size_t len) const
1794 {
1795 if (nLength < (index + len))
1796 return false;
1797
1798 const lsp_wchar_t *p = &pData[index];
1799 for (size_t i=0; i<len; ++i)
1800 if (p[i] != src[i])
1801 return false;
1802
1803 return true;
1804 }
1805
1806 bool LSPString::contains_at_ascii(ssize_t index, const char *src) const
1807 {
1808 const lsp_wchar_t *p = &pData[index];
1809 while (*src != '\0')
1810 {
1811 if (size_t(++index) > nLength)
1812 return false;
1813 if (lsp_wchar_t(*(p++)) != uint8_t(*(src++)))
1814 return false;
1815 }
1816
1817 return true;
1818 }
1819
1820 bool LSPString::contains_at_utf8(ssize_t index, const char *src) const
1821 {
1822 LSPString tmp;
1823 return (tmp.set_utf8(src)) ? contains_at(index, &tmp) : false;
1824 }
1825
1826 bool LSPString::contains_at_utf16(ssize_t index, const lsp_utf16_t *src) const
1827 {
1828 LSPString tmp;
1829 return (tmp.set_utf16(src)) ? contains_at(index, &tmp) : false;
1830 }
1831
1832 bool LSPString::set_utf8(const char *s, size_t n)
1833 {
1834 LSPString tmp;
1835 lsp_wchar_t ch;
1836
1837 while (lsp_utf32_t(ch = read_utf8_streaming(&s, &n, true)) != LSP_UTF32_EOF)
1838 {
1839 // Append code point
1840 if (!tmp.append(ch))
1841 return false;
1842 }
1843 if (n > 0)
1844 return false;
1845
1846 tmp.swap(this);
1847 return true;
1848 }
1849
1850 bool LSPString::set_utf16(const lsp_utf16_t *s)
1851 {
1852 return set_utf16(s, u16len(s));
1853 }
1854
1855 bool LSPString::set_utf16(const lsp_utf16_t *s, size_t n)
1856 {
1857 LSPString tmp;
1858 lsp_wchar_t ch;
1859
1860 while (lsp_utf32_t(ch = read_utf16_streaming(&s, &n, true)) != LSP_UTF32_EOF)
1861 {
1862 // Append code point
1863 if (!tmp.append(ch))
1864 return false;
1865 }
1866 if (n > 0)
1867 return false;
1868
1869 tmp.swap(this);
1870 return true;
1871 }
1872
1873 bool LSPString::set_utf16le(const lsp_utf16_t *s)
1874 {
1875 return set_utf16le(s, u16len(s));
1876 }
1877
1878 bool LSPString::set_utf16le(const lsp_utf16_t *s, size_t n)
1879 {
1880 LSPString tmp;
1881 lsp_wchar_t ch;
1882
1883 while (lsp_utf32_t(ch = read_utf16le_streaming(&s, &n, true)) != LSP_UTF32_EOF)
1884 {
1885 // Append code point
1886 if (!tmp.append(ch))
1887 return false;
1888 }
1889 if (n > 0)
1890 return false;
1891
1892 tmp.swap(this);
1893 return true;
1894 }
1895
1896 bool LSPString::set_utf16be(const lsp_utf16_t *s)
1897 {
1898 return set_utf16be(s, u16len(s));
1899 }
1900
1901 bool LSPString::set_utf16be(const lsp_utf16_t *s, size_t n)
1902 {
1903 LSPString tmp;
1904 lsp_wchar_t ch;
1905
1906 while (lsp_utf32_t(ch = read_utf16be_streaming(&s, &n, true)) != LSP_UTF32_EOF)
1907 {
1908 // Append code point
1909 if (!tmp.append(ch))
1910 return false;
1911 }
1912 if (n > 0)
1913 return false;
1914
1915 tmp.swap(this);
1916 return true;
1917 }
1918
1919 #if defined(PLATFORM_WINDOWS)
1920 bool LSPString::set_native(const char *s, size_t n, const char *charset)
1921 {
1922 if (s == NULL)
1923 return false;
1924 else if (n == 0)
1925 {
1926 nLength = 0;
1927 return true;
1928 }
1929
1930 // Get codepage
1931 ssize_t cp = codepage_from_name(charset);
1932 if (cp < 0)
1933 return false;
1934
1935 // Estimate size of string in memory
1936 ssize_t slen = multibyte_to_widechar(cp, const_cast<char *>(s), &n, NULL, NULL);
1937 if (slen <= 0)
1938 return false;
1939
1940 // Perform native -> utf-16 encoding
1941 lsp_utf16_t *buf = reinterpret_cast<lsp_utf16_t *>(::malloc(slen * sizeof(lsp_utf16_t)));
1942 if (buf == NULL)
1943 return false;
1944
1945 size_t bytes = slen;
1946 slen = multibyte_to_widechar(cp, const_cast<char *>(s), &n, buf, &bytes);
1947 if (slen <= 0)
1948 {
1949 free(buf);
1950 return false;
1951 }
1952
1953 // Set encoded utf-16 values
1954 bool res = set_utf16(buf, slen);
1955 free(buf);
1956
1957 return res;
1958 }
1959 #else
1960 bool LSPString::set_native(const char *s, size_t n, const char *charset)
1961 {
1962 if (s == NULL)
1963 return false;
1964 else if (n == 0)
1965 {
1966 nLength = 0;
1967 return true;
1968 }
1969
1970 char buf[BUF_SIZE];
1971 LSPString temp;
1972
1973 // Open conversion
1974 iconv_t cd = init_iconv_to_wchar_t(charset);
1975 if (cd == iconv_t(-1))
1976 return set_utf8(s, n);
1977
1978 size_t insize = n;
1979 size_t outsize = BUF_SIZE;
1980 char *inbuf = const_cast<char *>(s);
1981 char *outbuf = buf;
1982
1983 while (insize > 0)
1984 {
1985 // Do the conversion
1986 size_t nconv = iconv(cd, &inbuf, &insize, &outbuf, &outsize);
1987
1988 if (nconv == (size_t) -1)
1989 {
1990 switch (errno)
1991 {
1992 case E2BIG:
1993 case EINVAL:
1994 break;
1995 default:
1996 iconv_close(cd);
1997 return false;
1998 }
1999 }
2000
2001 // Append set of converted characters to string
2002 ssize_t n_chars = (BUF_SIZE - outsize) / sizeof(lsp_wchar_t);
2003 if (n_chars > 0)
2004 {
2005 if (!temp.append(reinterpret_cast<lsp_wchar_t *>(&buf[0]), n_chars))
2006 {
2007 iconv_close(cd);
2008 return false;
2009 }
2010 }
2011
2012 size_t right = n_chars * sizeof(lsp_wchar_t);
2013 ssize_t tail = (outsize - right) % sizeof(lsp_wchar_t);
2014 if (tail > 0)
2015 {
2016 // If there is a tail, copy it to the start of buffer
2017 ::memmove(buf, &buf[right], tail);
2018 outbuf = &buf[tail];
2019 outsize = BUF_SIZE - tail;
2020 }
2021 else
2022 {
2023 // Otherwise just reset buffer's pointer
2024 outbuf = buf;
2025 outsize = BUF_SIZE;
2026 }
2027 }
2028
2029 // Close descriptor
2030 iconv_close(cd);
2031 take(&temp);
2032 return true;
2033 }
2034 #endif /* PLATFORM_WINDOWS */
2035
2036 bool LSPString::set_ascii(const char *s, size_t n)
2037 {
2038 LSPString tmp;
2039 if (!tmp.reserve(n))
2040 return false;
2041
2042 acopy(tmp.pData, s, n);
2043 take(&tmp);
2044 nLength = n;
2045 nHash = 0;
2046 return true;
2047 }
2048
2049 const char *LSPString::get_utf8(ssize_t first, ssize_t last) const
2050 {
2051 XSAFE_TRANS(first, nLength, NULL);
2052 XSAFE_TRANS(last, nLength, NULL);
2053 if (first > last)
2054 return NULL;
2055
2056 if (pTemp != NULL)
2057 pTemp->nOffset = 0;
2058
2059 char temp[BUF_SIZE + 16];
2060 char *th = temp, *tt = &temp[BUF_SIZE];
2061
2062 for (ssize_t i=first; i<last; ++i)
2063 {
2064 lsp_wchar_t ch = pData[i];
2065 write_utf8_codepoint(&th, ch);
2066
2067 if (th >= tt)
2068 {
2069 if (!append_temp(temp, th - temp))
2070 return NULL;
2071 th = temp;
2072 }
2073 }
2074
2075 *(th++) = '\0';
2076 if (!append_temp(temp, th - temp))
2077 return NULL;
2078
2079 return pTemp->pData;
2080 }
2081
2082 const lsp_utf16_t *LSPString::get_utf16(ssize_t first, ssize_t last) const
2083 {
2084 XSAFE_TRANS(first, nLength, NULL);
2085 XSAFE_TRANS(last, nLength, NULL);
2086 if (first > last)
2087 return NULL;
2088
2089 if (pTemp != NULL)
2090 pTemp->nOffset = 0;
2091
2092 lsp_utf16_t temp[BUF_SIZE + 8];
2093 lsp_utf16_t *th = temp, *tt = &temp[BUF_SIZE];
2094
2095 for (ssize_t i=first; i<last; ++i)
2096 {
2097 lsp_wchar_t ch = pData[i];
2098 write_utf16_codepoint(&th, ch);
2099
2100 if (th >= tt)
2101 {
2102 if (!append_temp(reinterpret_cast<char *>(temp), (th - temp) * sizeof(lsp_utf16_t)))
2103 return NULL;
2104 th = temp;
2105 }
2106 }
2107
2108 *(th++) = '\0';
2109 if (!append_temp(reinterpret_cast<char *>(temp), (th - temp) * sizeof(lsp_utf16_t)))
2110 return NULL;
2111
2112 return reinterpret_cast<lsp_utf16_t *>(pTemp->pData);
2113 }
2114
2115 const lsp_utf16_t *LSPString::get_utf16le(ssize_t first, ssize_t last) const
2116 {
2117 XSAFE_TRANS(first, nLength, NULL);
2118 XSAFE_TRANS(last, nLength, NULL);
2119 if (first > last)
2120 return NULL;
2121
2122 if (pTemp != NULL)
2123 pTemp->nOffset = 0;
2124
2125 lsp_utf16_t temp[BUF_SIZE + 8];
2126 lsp_utf16_t *th = temp, *tt = &temp[BUF_SIZE];
2127
2128 for (ssize_t i=first; i<last; ++i)
2129 {
2130 lsp_wchar_t ch = pData[i];
2131 write_utf16le_codepoint(&th, ch);
2132
2133 if (th >= tt)
2134 {
2135 if (!append_temp(reinterpret_cast<char *>(temp), (th - temp) * sizeof(lsp_utf16_t)))
2136 return NULL;
2137 th = temp;
2138 }
2139 }
2140
2141 *(th++) = '\0';
2142 if (!append_temp(reinterpret_cast<char *>(temp), (th - temp) * sizeof(lsp_utf16_t)))
2143 return NULL;
2144
2145 return reinterpret_cast<lsp_utf16_t *>(pTemp->pData);
2146 }
2147
2148 const lsp_utf16_t *LSPString::get_utf16be(ssize_t first, ssize_t last) const
2149 {
2150 XSAFE_TRANS(first, nLength, NULL);
2151 XSAFE_TRANS(last, nLength, NULL);
2152 if (first > last)
2153 return NULL;
2154
2155 if (pTemp != NULL)
2156 pTemp->nOffset = 0;
2157
2158 lsp_utf16_t temp[BUF_SIZE + 8];
2159 lsp_utf16_t *th = temp, *tt = &temp[BUF_SIZE];
2160
2161 for (ssize_t i=first; i<last; ++i)
2162 {
2163 lsp_wchar_t ch = pData[i];
2164 write_utf16be_codepoint(&th, ch);
2165
2166 if (th >= tt)
2167 {
2168 if (!append_temp(reinterpret_cast<char *>(temp), (th - temp) * sizeof(lsp_utf16_t)))
2169 return NULL;
2170 th = temp;
2171 }
2172 }
2173
2174 *(th++) = '\0';
2175 if (!append_temp(reinterpret_cast<char *>(temp), (th - temp) * sizeof(lsp_utf16_t)))
2176 return NULL;
2177
2178 return reinterpret_cast<lsp_utf16_t *>(pTemp->pData);
2179 }
2180
2181 const char *LSPString::get_ascii(ssize_t first, ssize_t last) const
2182 {
2183 XSAFE_TRANS(first, nLength, NULL);
2184 XSAFE_TRANS(last, nLength, NULL);
2185 if (first > last)
2186 return NULL;
2187
2188 if (!resize_temp(last - first + 1))
2189 return NULL;
2190
2191 lsp_wchar_t *p = &pData[first];
2192 char *dst = pTemp->pData;
2193
2194 for (; first < last; ++first)
2195 {
2196 lsp_wchar_t c = *(p++);
2197 *(dst++) = (c <= 0x7f) ? c : 0xff;
2198 }
2199
2200 *(dst++) = '\0';
2201 pTemp->nOffset = dst - pTemp->pData;
2202
2203 return pTemp->pData;
2204 }
2205
2206 #if defined(PLATFORM_WINDOWS)
2207 const char *LSPString::get_native(ssize_t first, ssize_t last, const char *charset) const
2208 {
2209 XSAFE_TRANS(first, nLength, NULL);
2210 XSAFE_TRANS(last, nLength, NULL);
2211 ssize_t length = last - first;
2212 if (length < 0)
2213 return NULL;
2214 else if (length == 0)
2215 return "";
2216
2217 // Get codepage
2218 ssize_t cp = codepage_from_name(charset);
2219 if (cp < 0)
2220 return NULL;
2221
2222 // Estimate number of bytes required
2223 lsp_utf16_t *buf = const_cast<lsp_utf16_t *>(get_utf16(first, last));
2224 if (buf == NULL)
2225 return NULL;
2226 lsp_finally{ free(buf); };
2227
2228 // Drop temporary data because it is stored in buf variable and can not be reused
2229 pTemp->pData = NULL;
2230 pTemp->nLength = 0;
2231 pTemp->nOffset = 0;
2232
2233 size_t slen = length;
2234 ssize_t res = widechar_to_multibyte(cp, buf, &slen, NULL, NULL) + 4; // + terminating 0
2235 if ((res <= 0) || (!resize_temp(res)))
2236 return NULL;
2237
2238 // We have enough space for saving data
2239 size_t n = res;
2240 res = widechar_to_multibyte(cp, buf, &slen, pTemp->pData, &n);
2241 if (res <= 0)
2242 return NULL;
2243
2244 // Append terminating zero
2245 pTemp->pData[res++] = '\0';
2246 pTemp->pData[res++] = '\0';
2247 pTemp->pData[res++] = '\0';
2248 pTemp->pData[res++] = '\0';
2249 pTemp->nOffset = res;
2250
2251 return pTemp->pData;
2252 }
2253 #else
2254 const char *LSPString::get_native(ssize_t first, ssize_t last, const char *charset) const
2255 {
2256 XSAFE_TRANS(first, nLength, NULL);
2257 XSAFE_TRANS(last, nLength, NULL);
2258 if (first > last)
2259 return NULL;
2260
2261 // Open conversion
2262 iconv_t cd = init_iconv_from_wchar_t(charset);
2263 if (cd == iconv_t(-1))
2264 return get_utf8(first, last);
2265
2266 // Analyze temp
2267 size_t outsize = 0;
2268 char *outbuf = NULL;
2269 if (pTemp != NULL)
2270 {
2271 pTemp->nOffset = 0;
2272 outsize = pTemp->nLength;
2273 outbuf = pTemp->pData;
2274 }
2275
2276 size_t insize = (last - first) * sizeof(lsp_wchar_t);
2277 char *inbuf = reinterpret_cast<char *>(const_cast<lsp_wchar_t *>(&pData[first]));
2278
2279 while (insize > 0)
2280 {
2281 // Reserve space if there is not enough space
2282 if (outsize < 16)
2283 {
2284 // Try to grow the temprary buffer
2285 if (!grow_temp(BUF_SIZE))
2286 {
2287 iconv_close(cd);
2288 return NULL;
2289 }
2290
2291 // Initialize location of buffers to store data
2292 outsize = pTemp->nLength - pTemp->nOffset;
2293 outbuf = &pTemp->pData[pTemp->nOffset];
2294 }
2295
2296 // Do the conversion
2297 size_t nconv = iconv(cd, &inbuf, &insize, &outbuf, &outsize);
2298 if (nconv == (size_t) -1)
2299 {
2300 int err_code = errno;
2301 switch (err_code)
2302 {
2303 case E2BIG:
2304 case EINVAL:
2305 break;
2306 default:
2307 iconv_close (cd);
2308 return NULL;
2309 }
2310 }
2311
2312 // Update pointer
2313 pTemp->nOffset = pTemp->nLength - outsize;
2314 }
2315
2316 // Close the iconv descriptor
2317 iconv_close(cd);
2318
2319 // Append zeros at the end to make compatible with C-strings
2320 if (!append_temp("\x00\x00\x00\x00", 4))
2321 return NULL;
2322
2323 return pTemp->pData;
2324 }
2325 #endif /* PLATFORM_WINDOWS */
2326
2327 size_t LSPString::match(const LSPString *s, size_t index) const
2328 {
2329 if (index >= nLength)
2330 return 0;
2331 size_t i=0, n = lsp_min(s->nLength, nLength - index);
2332
2333 for (; i < n; ++i)
2334 {
2335 if (pData[i] != s->pData[i])
2336 return i;
2337 }
2338 return i;
2339 }
2340
2341 size_t LSPString::match_nocase(const LSPString *s, size_t index) const
2342 {
2343 if (index >= nLength)
2344 return 0;
2345 size_t i=0, n = lsp_min(s->nLength, nLength - index);
2346
2347 for (; i < n; ++i)
2348 {
2349 if (lsp::to_lower(pData[i]) != lsp::to_lower(s->pData[i]))
2350 return i;
2351 }
2352 return i;
2353 }
2354
2355 char *LSPString::clone_utf8(size_t *bytes, ssize_t first, ssize_t last) const
2356 {
2357 const char *utf8 = get_utf8(first, last);
2358 if (utf8 == NULL)
2359 return NULL;
2360
2361 size_t offset = (pTemp != NULL) ? pTemp->nOffset : 0;
2362 char *ptr = reinterpret_cast<char *>(lsp::memdup(utf8, offset));
2363 if (bytes != NULL)
2364 *bytes = (ptr != NULL) ? offset : 0;
2365 return ptr;
2366 }
2367
2368 lsp_utf16_t *LSPString::clone_utf16(size_t *bytes, ssize_t first, ssize_t last) const
2369 {
2370 const lsp_utf16_t *utf16 = get_utf16(first, last);
2371 if (utf16 == NULL)
2372 return NULL;
2373
2374 size_t offset = (pTemp != NULL) ? pTemp->nOffset : 0;
2375 lsp_utf16_t *ptr = reinterpret_cast<lsp_utf16_t *>(lsp::memdup(utf16, offset));
2376 if (bytes != NULL)
2377 *bytes = (ptr != NULL) ? offset : 0;
2378 return ptr;
2379 }
2380
2381 lsp_utf16_t *LSPString::clone_utf16le(size_t *bytes, ssize_t first, ssize_t last) const
2382 {
2383 const lsp_utf16_t *utf16 = get_utf16le(first, last);
2384 if (utf16 == NULL)
2385 return NULL;
2386
2387 size_t offset = (pTemp != NULL) ? pTemp->nOffset : 0;
2388 lsp_utf16_t *ptr = reinterpret_cast<lsp_utf16_t *>(lsp::memdup(utf16, offset));
2389 if (bytes != NULL)
2390 *bytes = (ptr != NULL) ? offset : 0;
2391 return ptr;
2392 }
2393
2394 lsp_utf16_t *LSPString::clone_utf16be(size_t *bytes, ssize_t first, ssize_t last) const
2395 {
2396 const lsp_utf16_t *utf16 = get_utf16be(first, last);
2397 if (utf16 == NULL)
2398 return NULL;
2399
2400 size_t offset = (pTemp != NULL) ? pTemp->nOffset : 0;
2401 lsp_utf16_t *ptr = reinterpret_cast<lsp_utf16_t *>(lsp::memdup(utf16, offset));
2402 if (bytes != NULL)
2403 *bytes = (ptr != NULL) ? offset : 0;
2404 return ptr;
2405 }
2406
2407 char *LSPString::clone_ascii(size_t *bytes, ssize_t first, ssize_t last) const
2408 {
2409 const char *ascii = get_ascii(first, last);
2410 if (ascii == NULL)
2411 return NULL;
2412
2413 size_t offset = (pTemp != NULL) ? pTemp->nOffset : 0;
2414 char *ptr = reinterpret_cast<char *>(lsp::memdup(ascii, offset));
2415 if (bytes != NULL)
2416 *bytes = (ptr != NULL) ? offset : 0;
2417 return ptr;
2418 }
2419
2420 char *LSPString::clone_native(size_t *bytes, ssize_t first, ssize_t last, const char *charset) const
2421 {
2422 const char *native = get_native(first, last, charset);
2423 if (native == NULL)
2424 return NULL;
2425
2426 size_t offset = (pTemp != NULL) ? pTemp->nOffset : 0;
2427 char *ptr = reinterpret_cast<char *>(lsp::memdup(native, offset));
2428 if (bytes != NULL)
2429 *bytes = (ptr != NULL) ? offset : 0;
2430 return ptr;
2431 }
2432
2433 bool LSPString::append_temp(const char *p, size_t n) const
2434 {
2435 ssize_t free = (pTemp != NULL) ? pTemp->nLength - pTemp->nOffset : -1;
2436
2437 if (free < ssize_t(n))
2438 {
2439 size_t resize = n + (n >> 1);
2440 if (pTemp != NULL)
2441 resize += pTemp->nLength;
2442
2443 if (!resize_temp(resize))
2444 return false;
2445 }
2446
2447 memcpy(&pTemp->pData[pTemp->nOffset], p, n * sizeof(char));
2448 pTemp->nOffset += n;
2449
2450 return true;
2451 }
2452
2453 bool LSPString::grow_temp(size_t n) const
2454 {
2455 if (pTemp == NULL)
2456 {
2457 pTemp = static_cast<buffer_t *>(malloc(sizeof(buffer_t)));
2458 if (pTemp == NULL)
2459 return false;
2460 pTemp->nLength = 0;
2461 pTemp->nOffset = 0;
2462 pTemp->pData = 0;
2463 }
2464
2465 char *xc = static_cast<char *>(realloc(pTemp->pData, (pTemp->nLength + n)*sizeof(char)));
2466 if (xc == NULL)
2467 return false;
2468
2469 pTemp->pData = xc;
2470 pTemp->nLength += n;
2471 return true;
2472 }
2473
2474 bool LSPString::resize_temp(size_t n) const
2475 {
2476 if (pTemp == NULL)
2477 {
2478 pTemp = static_cast<buffer_t *>(malloc(sizeof(buffer_t)));
2479 if (pTemp == NULL)
2480 return false;
2481 pTemp->nLength = 0;
2482 pTemp->nOffset = 0;
2483 pTemp->pData = 0;
2484 }
2485
2486 char *xc = static_cast<char *>(realloc(pTemp->pData, n*sizeof(char)));
2487 if (xc == NULL)
2488 return false;
2489
2490 pTemp->pData = xc;
2491 pTemp->nLength = n;
2492 return true;
2493 }
2494
2495 size_t LSPString::count(lsp_wchar_t ch) const
2496 {
2497 size_t n = 0;
2498 for (size_t i=0; i<nLength; ++i)
2499 if (pData[i] == ch)
2500 ++n;
2501 return n;
2502 }
2503
2504 size_t LSPString::count(lsp_wchar_t ch, ssize_t first) const
2505 {
2506 XSAFE_TRANS(first, nLength, 0);
2507
2508 size_t n = 0;
2509 for (size_t i=first; i<nLength; ++i)
2510 if (pData[i] == ch)
2511 ++n;
2512 return n;
2513 }
2514
2515 size_t LSPString::count(lsp_wchar_t ch, ssize_t first, ssize_t last) const
2516 {
2517 XSAFE_TRANS(first, nLength, 0);
2518 XSAFE_TRANS(last, nLength, 0);
2519
2520 size_t n = 0;
2521 if (first < last)
2522 {
2523 for (ssize_t i=first; i<last; ++i)
2524 if (pData[i] == ch)
2525 ++n;
2526 }
2527 else
2528 {
2529 for (ssize_t i=last; i<first; ++i)
2530 if (pData[i] == ch)
2531 ++n;
2532 }
2533 return n;
2534 }
2535
2536 ssize_t LSPString::fmt_append_native(const char *fmt...)
2537 {
2538 LSPString tmp;
2539 va_list vl;
2540 va_start(vl, fmt);
2541 ssize_t res = tmp.vfmt_native(fmt, vl);
2542 va_end(vl);
2543 if (res < 0)
2544 return -res;
2545 return (append(&tmp)) ? res : -STATUS_NO_MEM;
2546 }
2547
2548 ssize_t LSPString::fmt_preend_native(const char *fmt...)
2549 {
2550 LSPString tmp;
2551 va_list vl;
2552 va_start(vl, fmt);
2553 ssize_t res = tmp.vfmt_native(fmt, vl);
2554 va_end(vl);
2555 if (res < 0)
2556 return res;
2557 return (prepend(&tmp)) ? res : -STATUS_NO_MEM;
2558 }
2559
2560 ssize_t LSPString::fmt_native(const char *fmt...)
2561 {
2562 va_list vl;
2563 va_start(vl, fmt);
2564 ssize_t res = vfmt_native(fmt, vl);
2565 va_end(vl);
2566 return res;
2567 }
2568
2569 ssize_t LSPString::vfmt_append_native(const char *fmt, va_list args)
2570 {
2571 LSPString tmp;
2572 ssize_t res = tmp.vfmt_native(fmt, args);
2573 if (res < 0)
2574 return res;
2575 return (append(&tmp)) ? res : -STATUS_NO_MEM;
2576 }
2577
2578 ssize_t LSPString::vfmt_preend_native(const char *fmt, va_list args)
2579 {
2580 LSPString tmp;
2581 ssize_t res = tmp.vfmt_native(fmt, args);
2582 if (res < 0)
2583 return res;
2584 return (prepend(&tmp)) ? res : -STATUS_NO_MEM;
2585 }
2586
2587 ssize_t LSPString::vfmt_native(const char *fmt, va_list args)
2588 {
2589 char *ptr = NULL;
2590 ssize_t res = vasprintf(&ptr, fmt, args);
2591 if ((ptr == NULL) || (res < 0))
2592 return -STATUS_NO_MEM;
2593 if (!set_native(ptr, res))
2594 res = -STATUS_NO_MEM;
2595 free(ptr);
2596 return res;
2597 }
2598
2599 ssize_t LSPString::fmt_append_ascii(const char *fmt...)
2600 {
2601 LSPString tmp;
2602 va_list vl;
2603 va_start(vl, fmt);
2604 ssize_t res = tmp.vfmt_ascii(fmt, vl);
2605 va_end(vl);
2606 if (res < 0)
2607 return res;
2608 return (append(&tmp)) ? res : -STATUS_NO_MEM;
2609 }
2610
2611 ssize_t LSPString::fmt_prepend_ascii(const char *fmt...)
2612 {
2613 LSPString tmp;
2614 va_list vl;
2615 va_start(vl, fmt);
2616 ssize_t res = tmp.vfmt_ascii(fmt, vl);
2617 va_end(vl);
2618 if (res < 0)
2619 return res;
2620 return (prepend(&tmp)) ? res : -STATUS_NO_MEM;
2621 }
2622
2623 ssize_t LSPString::fmt_ascii(const char *fmt...)
2624 {
2625 va_list vl;
2626 va_start(vl, fmt);
2627 ssize_t res = vfmt_ascii(fmt, vl);
2628 va_end(vl);
2629 return res;
2630 }
2631
2632 ssize_t LSPString::vfmt_append_ascii(const char *fmt, va_list args)
2633 {
2634 LSPString tmp;
2635 ssize_t res = tmp.vfmt_ascii(fmt, args);
2636 if (res < 0)
2637 return res;
2638 return (append(&tmp)) ? res : -STATUS_NO_MEM;
2639 }
2640
2641 ssize_t LSPString::vfmt_prepend_ascii(const char *fmt, va_list args)
2642 {
2643 LSPString tmp;
2644 ssize_t res = tmp.vfmt_ascii(fmt, args);
2645 if (res < 0)
2646 return res;
2647 return (prepend(&tmp)) ? res : -STATUS_NO_MEM;
2648 }
2649
2650 ssize_t LSPString::vfmt_ascii(const char *fmt, va_list args)
2651 {
2652 char *ptr = NULL;
2653 ssize_t res = vasprintf(&ptr, fmt, args);
2654 if ((ptr == NULL) || (res < 0))
2655 return -STATUS_NO_MEM;
2656 if (!set_ascii(ptr, res))
2657 res = -STATUS_NO_MEM;
2658 free(ptr);
2659 return res;
2660 }
2661
2662 ssize_t LSPString::fmt_append_utf8(const char *fmt...)
2663 {
2664 LSPString tmp;
2665 va_list vl;
2666 va_start(vl, fmt);
2667 ssize_t res = tmp.vfmt_utf8(fmt, vl);
2668 va_end(vl);
2669 if (res < 0)
2670 return res;
2671 return (append(&tmp)) ? res : -STATUS_NO_MEM;
2672 }
2673
2674 ssize_t LSPString::fmt_prepend_utf8(const char *fmt...)
2675 {
2676 LSPString tmp;
2677 va_list vl;
2678 va_start(vl, fmt);
2679 ssize_t res = tmp.vfmt_utf8(fmt, vl);
2680 va_end(vl);
2681 if (res < 0)
2682 return res;
2683 return (prepend(&tmp)) ? res : -STATUS_NO_MEM;
2684 }
2685
2686 ssize_t LSPString::fmt_utf8(const char *fmt...)
2687 {
2688 va_list vl;
2689 va_start(vl, fmt);
2690 ssize_t res = vfmt_utf8(fmt, vl);
2691 va_end(vl);
2692 return res;
2693 }
2694
2695 ssize_t LSPString::vfmt_append_utf8(const char *fmt, va_list args)
2696 {
2697 LSPString tmp;
2698 ssize_t res = tmp.vfmt_utf8(fmt, args);
2699 if (res < 0)
2700 return res;
2701 return (append(&tmp)) ? res : -STATUS_NO_MEM;
2702 }
2703
2704 ssize_t LSPString::vfmt_prepend_utf8(const char *fmt, va_list args)
2705 {
2706 LSPString tmp;
2707 ssize_t res = tmp.vfmt_utf8(fmt, args);
2708 if (res < 0)
2709 return res;
2710 return (prepend(&tmp)) ? res : -STATUS_NO_MEM;
2711 }
2712
2713 ssize_t LSPString::vfmt_utf8(const char *fmt, va_list args)
2714 {
2715 char *ptr = NULL;
2716 ssize_t res = vasprintf(&ptr, fmt, args);
2717 if ((ptr == NULL) || (res < 0))
2718 return -STATUS_NO_MEM;
2719 if (!set_utf8(ptr, res))
2720 res = -STATUS_NO_MEM;
2721 free(ptr);
2722 return res;
2723 }
2724
2725 size_t LSPString::hash() const
2726 {
2727 if (pData == NULL)
2728 return 0;
2729 else if (nHash != 0)
2730 return nHash;
2731
2732 size_t hash = 0;
2733 for (size_t i=0; i<nLength; ++i)
2734 hash = (hash * 0x10015) ^ pData[i];
2735
2736 return nHash = hash;
2737 }
2738
2739 bool LSPString::to_dos()
2740 {
2741 // Step 1: estimate the number of unprocessed line endings
2742 size_t count = 0;
2743 for (size_t i=0; i<nLength; ++i)
2744 {
2745 if (pData[i] != '\n')
2746 continue;
2747 if ((i == 0) || (pData[i-1] != '\r'))
2748 ++count;
2749 }
2750
2751 // Return if there are no changes
2752 if (count <= 0)
2753 return true;
2754 else if (!cap_grow(count))
2755 return false;
2756 drop_temp();
2757 nHash = 0;
2758
2759 // Now we need to replace all line endings with proper ones
2760 size_t distance;
2761 lsp_wchar_t *dst = &pData[nLength + count];
2762 const lsp_wchar_t *src = &pData[nLength];
2763 const lsp_wchar_t *blk;
2764 nLength += count;
2765
2766 while (count-- > 0)
2767 {
2768 // Find the occurrence
2769 for (blk = src-1; blk > pData; --blk)
2770 {
2771 if (*blk != '\n')
2772 continue;
2773 if (blk[-1] != '\r')
2774 break;
2775 }
2776
2777 // blk now points at the block before the '\r' symbol
2778 distance = src - blk;
2779 dst -= distance;
2780 if (distance > 0)
2781 memmove(dst, blk, distance * sizeof(lsp_wchar_t));
2782 src = blk;
2783 *(--dst) = '\r';
2784 }
2785
2786 return true;
2787 }
2788
2789 bool LSPString::to_unix()
2790 {
2791 // Step 1: estimate the number of unprocessed line endings
2792 size_t count = 0;
2793 for (size_t i=1; i<nLength; ++i)
2794 {
2795 if (pData[i] != '\n')
2796 continue;
2797 if (pData[i-1] == '\r')
2798 ++count;
2799 }
2800
2801 // Return if there are no changes
2802 if (count <= 0)
2803 return true;
2804 drop_temp();
2805 nHash = 0;
2806
2807 size_t distance;
2808 lsp_wchar_t *dst = pData;
2809 const lsp_wchar_t *src = pData;
2810 const lsp_wchar_t *end = &pData[nLength];
2811 const lsp_wchar_t *blk;
2812 nLength -= count;
2813
2814 while (count-- > 0)
2815 {
2816 // Find the occurrence
2817 for (blk = src + 1; blk < end; ++blk)
2818 {
2819 if (*blk != '\n')
2820 continue;
2821 if ((blk > pData) && (blk[-1] == '\r'))
2822 break;
2823 }
2824
2825 // blk now points at the end of block before the '\r' symbol
2826 distance = blk - src - 1;
2827 if ((distance > 0) && (src != dst))
2828 memmove(dst, src, distance * sizeof(lsp_wchar_t));
2829 src += distance + 1;
2830 dst += distance;
2831 }
2832
2833 // move the rest data
2834 if (src < end)
2835 memmove(dst, src, (end - src) * sizeof(lsp_wchar_t));
2836
2837 return true;
2838 }
2839
2840 namespace lltl
2841 {
2842 size_t hash_spec<LSPString>::hash_func(const void *ptr, size_t size)
2843 {
2844 return (static_cast<const LSPString *>(ptr))->hash();
2845 }
2846
2847 ssize_t compare_spec<LSPString>::cmp_func(const void *a, const void *b, size_t size)
2848 {
2849 const LSPString *sa = static_cast<const LSPString *>(a);
2850 const LSPString *sb = static_cast<const LSPString *>(b);
2851 return sa->compare_to(sb);
2852 }
2853
2854 void *allocator_spec<LSPString>::clone_func(const void *src, size_t size)
2855 {
2856 return (static_cast<const LSPString *>(src))->clone();
2857 }
2858
2859 void allocator_spec<LSPString>::free_func(void *ptr)
2860 {
2861 delete (static_cast<LSPString *>(ptr));
2862 }
2863 }
2864
2865 } /* namespace lsp */