/*
* Copyright (C) 2024 Linux Studio Plugins Project
* (C) 2024 Vladimir Sadovnikov
*
* This file is part of lsp-runtime-lib
* Created on: 30 авг. 2017 г.
*
* lsp-runtime-lib is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* lsp-runtime-lib is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with lsp-runtime-lib. If not, see .
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define GRANULARITY 0x20
#define BUF_SIZE 0x200
//#define BUF_SIZE 16
#define XSAFE_TRANS(index, length, result) \
if (index < 0) \
{ \
if ((index += (length)) < 0) \
return result; \
} \
else if (size_t(index) > (length)) \
return result;
#define XSAFE_ITRANS(index, length, result) \
if (index < 0) \
{ \
if ((index += (length)) < 0) \
return result; \
} \
else if (size_t(index) >= (length)) \
return result;
namespace lsp
{
static bool is_space(lsp_wchar_t c)
{
switch (c)
{
case ' ':
case '\t':
case '\n':
case '\r':
case '\v':
return true;
default:
return false;
}
}
LSPString::LSPString()
{
nLength = 0;
nCapacity = 0;
pData = NULL;
nHash = 0;
pTemp = NULL;
}
LSPString::~LSPString()
{
truncate();
}
#ifndef ARCH_LE
int LSPString::xcmp(const lsp_wchar_t *a, const lsp_wchar_t *b, size_t n)
{
while (n--)
{
int32_t retval = int32_t(*(a++)) - int32_t(*(b++));
if (retval != 0)
return (retval > 0) ? 1 : -1;
}
return 0;
}
#endif /* ARCH_LE */
inline size_t LSPString::xlen(const lsp_wchar_t *s)
{
size_t i=0;
while (s[i] != 0)
++i;
return i;
}
inline size_t LSPString::u16len(const lsp_utf16_t *s)
{
size_t i=0;
while (s[i] != 0)
++i;
return i;
}
int LSPString::xcasecmp(const lsp_wchar_t *a, const lsp_wchar_t *b, size_t n)
{
while (n--)
{
int32_t retval = int32_t(lsp::to_lower(*(a++))) - int32_t(lsp::to_lower(*(b++)));
if (retval != 0)
return (retval > 0) ? 1 : -1;
}
return 0;
}
void LSPString::acopy(lsp_wchar_t *dst, const char *src, size_t n)
{
while (n--)
*(dst++) = uint8_t(*(src++));
}
void LSPString::drop_temp()
{
if (pTemp == NULL)
return;
if (pTemp->pData != NULL)
::free(pTemp->pData);
::free(pTemp);
pTemp = NULL;
}
void LSPString::clear()
{
drop_temp();
nLength = 0;
nHash = 0;
}
void LSPString::truncate()
{
drop_temp();
nLength = 0;
nHash = 0;
nCapacity = 0;
if (pData == NULL)
return;
xfree(pData);
pData = NULL;
}
bool LSPString::truncate(size_t size)
{
drop_temp();
if (size > nCapacity)
return true;
if (nLength > size)
{
nHash = 0;
nLength = size;
}
lsp_wchar_t *v = xrealloc(pData, size);
if ((v == NULL) && (size > 0))
return false;
pData = (size > 0) ? v : NULL;
nCapacity = size;
return true;
}
size_t LSPString::set_length(size_t length)
{
if (nLength <= length)
return length;
drop_temp();
nHash = 0;
return nLength = length;
}
size_t LSPString::range_length(ssize_t first, ssize_t last) const
{
XSAFE_TRANS(first, nLength, 0);
XSAFE_TRANS(last, nLength, 0);
return (first < last) ? last - first : 0;
}
bool LSPString::size_reserve(size_t size)
{
if (size > 0)
{
lsp_wchar_t *v = xrealloc(pData, size);
if (v == NULL)
return false;
pData = v;
}
else if (pData != NULL)
{
::free(pData);
pData = NULL;
}
nCapacity = size;
return true;
}
inline bool LSPString::cap_reserve(size_t size)
{
size_t ncap = (size + (GRANULARITY-1)) & (~(GRANULARITY-1));
return (ncap > nCapacity) ? size_reserve(ncap) : true;
}
inline bool LSPString::cap_grow(size_t delta)
{
size_t avail = nCapacity - nLength;
if (delta <= avail)
return true;
avail = nCapacity >> 1;
if (avail < delta)
avail = delta;
return size_reserve(nCapacity + ((avail + (GRANULARITY-1)) & (~(GRANULARITY-1))));
}
void LSPString::reduce()
{
drop_temp();
if (nCapacity <= nLength)
return;
lsp_wchar_t *v = xrealloc(pData, nLength);
if ((v == NULL) && (nLength > 0))
return;
pData = (nLength > 0) ? v : NULL;
nCapacity = nLength;
}
void LSPString::trim()
{
if ((pData == NULL) || (nLength <= 0))
return;
// Cut tail first
lsp_wchar_t *p = &pData[nLength];
while (nLength > 0)
{
if (!is_space(*(--p)))
break;
nLength--;
nHash = 0;
}
if (nLength <= 0)
return;
// Cut head
p = pData;
while (true)
{
if (!is_space(*p))
break;
p++;
}
if (p > pData)
{
nHash = 0;
nLength -= (p - pData);
}
if (nLength <= 0)
return;
xmove(pData, p, nLength);
}
void LSPString::swap(LSPString *src)
{
if (src == this)
return;
size_t len = src->nLength;
size_t cap = src->nCapacity;
lsp_wchar_t *c = src->pData;
size_t hash = src->nHash;
src->nLength = nLength;
src->nCapacity = nCapacity;
src->pData = pData;
src->nHash = nHash;
nLength = len;
nCapacity = cap;
pData = c;
nHash = hash;
}
bool LSPString::swap(ssize_t idx1, ssize_t idx2)
{
XSAFE_ITRANS(idx1, nLength, false);
XSAFE_ITRANS(idx2, nLength, false);
if (idx1 == idx2)
return true;
// Swap characters
nHash = 0;
lsp_wchar_t c = pData[idx1];
pData[idx1] = pData[idx2];
pData[idx2] = c;
return true;
}
void LSPString::take(LSPString *src)
{
drop_temp();
if (pData != NULL)
xfree(pData);
nLength = src->nLength;
nCapacity = src->nCapacity;
pData = src->pData;
nHash = src->nHash;
src->nLength = 0;
src->nCapacity = 0;
src->pData = NULL;
src->nHash = 0;
}
void LSPString::take(LSPString &src)
{
drop_temp();
if (pData != NULL)
xfree(pData);
nLength = src.nLength;
nCapacity = src.nCapacity;
pData = src.pData;
nHash = src.nHash;
src.nLength = 0;
src.nCapacity = 0;
src.pData = NULL;
src.nHash = 0;
}
LSPString *LSPString::copy() const
{
LSPString *s = new LSPString();
if (s == NULL)
return s;
s->nLength = nLength;
s->nCapacity = nLength;
if (s->nLength > 0)
{
s->pData = xmalloc(nLength);
if (s->pData == NULL)
{
delete s;
return NULL;
}
xmove(s->pData, pData, nLength);
}
else
s->pData = NULL;
return s;
}
LSPString *LSPString::release()
{
LSPString *str = new LSPString();
if (str != NULL)
str->swap(this);
return str;
}
LSPString *LSPString::copy(ssize_t first) const
{
LSPString *s = new LSPString();
if (s != NULL)
{
if (!s->set(this, first))
{
delete s;
s = NULL;
}
}
return s;
}
LSPString *LSPString::copy(ssize_t first, ssize_t last) const
{
LSPString *s = new LSPString();
if (s != NULL)
{
if (!s->set(this, first, last))
{
delete s;
s = NULL;
}
}
return s;
}
lsp_wchar_t LSPString::at(ssize_t index) const
{
if (index < 0)
{
if ((index += nLength) < 0)
return 0;
}
else if (size_t(index) >= nLength)
return 0;
return pData[index];
}
lsp_wchar_t LSPString::first() const
{
return (nLength > 0) ? pData[0] : 0;
}
lsp_wchar_t LSPString::last() const
{
return (nLength > 0) ? pData[nLength-1] : 0;
}
bool LSPString::set(lsp_wchar_t ch)
{
drop_temp();
if (nCapacity == 0)
{
lsp_wchar_t *v = xmalloc(GRANULARITY);
if (v == NULL)
return false;
v[0] = ch;
pData = v;
nCapacity = GRANULARITY;
}
else
pData[0] = ch;
nHash = 0;
nLength = 1;
return true;
}
bool LSPString::set(const lsp_wchar_t *arr)
{
return set(arr, xlen(arr));
}
bool LSPString::set(const lsp_wchar_t *arr, size_t n)
{
drop_temp();
if (!cap_reserve(n))
return false;
xmove(pData, arr, n);
nHash = 0;
nLength = n;
return true;
}
bool LSPString::set(ssize_t first, lsp_wchar_t ch)
{
XSAFE_ITRANS(first, nLength, false);
pData[first] = ch;
nHash = 0;
return true;
}
bool LSPString::set(const LSPString *src)
{
if (src == this)
return true;
drop_temp();
if (!cap_reserve(src->nLength))
return false;
if (src->nLength > 0)
xmove(pData, src->pData, src->nLength);
nLength = src->nLength;
nHash = 0;
return true;
}
bool LSPString::set(const LSPString *src, ssize_t first)
{
drop_temp();
XSAFE_TRANS(first, src->nLength, false);
ssize_t length = src->nLength - first;
if (length > 0)
{
if (!cap_reserve(length))
return false;
xmove(pData, &src->pData[first], length);
nLength = length;
}
else
nLength = 0;
nHash = 0;
return true;
}
bool LSPString::set(const LSPString *src, ssize_t first, ssize_t last)
{
drop_temp();
XSAFE_TRANS(first, src->nLength, false);
XSAFE_TRANS(last, src->nLength, false);
ssize_t length = last - first;
if (length > 0)
{
if (!cap_reserve(length))
return false;
xmove(pData, &src->pData[first], length);
nLength = length;
}
else
nLength = 0;
nHash = 0;
return true;
}
bool LSPString::insert(ssize_t pos, lsp_wchar_t ch)
{
XSAFE_TRANS(pos, nLength, false);
if (!cap_grow(1))
return false;
ssize_t length = nLength - pos;
if (length > 0)
xmove(&pData[pos+1], &pData[pos], length);
pData[pos] = ch;
nLength++;
nHash = 0;
return true;
}
bool LSPString::insert(ssize_t pos, const lsp_wchar_t *arr, ssize_t n)
{
XSAFE_TRANS(pos, nLength, false);
if (!cap_grow(n))
return false;
ssize_t count = nLength - pos;
if (count > 0)
xmove(&pData[pos+n], &pData[pos], count);
xmove(&pData[pos], arr, n);
nLength += n;
nHash = 0;
return true;
}
bool LSPString::insert(ssize_t pos, const LSPString *src)
{
if (src->nLength <= 0)
return true;
XSAFE_TRANS(pos, nLength, false);
if (!cap_grow(src->nLength))
return false;
ssize_t count = nLength - pos;
if (count > 0)
xmove(&pData[pos+src->nLength], &pData[pos], count);
xmove(&pData[pos], src->pData, src->nLength);
nLength += src->nLength;
nHash = 0;
return true;
}
bool LSPString::insert(ssize_t pos, const LSPString *src, ssize_t first)
{
XSAFE_TRANS(first, src->nLength, false);
ssize_t length = src->nLength - first;
if (length <= 0)
return true;
XSAFE_TRANS(pos, nLength, false);
if (!cap_grow(length))
return false;
ssize_t count = nLength - pos;
if (count > 0)
xmove(&pData[pos+length], &pData[pos], count);
xmove(&pData[pos], &src->pData[first], length);
nLength += length;
nHash = 0;
return true;
}
bool LSPString::insert(ssize_t pos, const LSPString *src, ssize_t first, ssize_t last)
{
XSAFE_TRANS(first, src->nLength, false);
XSAFE_TRANS(last, src->nLength, false);
ssize_t length = last - first;
if (length <= 0)
return true;
XSAFE_TRANS(pos, nLength, false);
if (!cap_grow(length))
return false;
ssize_t count = nLength - pos;
if (count > 0)
xmove(&pData[pos+length], &pData[pos], count);
xmove(&pData[pos], &src->pData[first], length);
nLength += length;
nHash = 0;
return true;
}
bool LSPString::append(char ch)
{
if (!cap_grow(1))
return false;
pData[nLength++] = uint8_t(ch);
nHash = 0;
return true;
}
bool LSPString::append(lsp_wchar_t ch)
{
if (!cap_grow(1))
return false;
pData[nLength++] = ch;
nHash = 0;
return true;
}
bool LSPString::append(lsp_swchar_t ch)
{
if (!cap_grow(1))
return false;
pData[nLength++] = ch;
nHash = 0;
return true;
}
bool LSPString::append(const lsp_wchar_t *arr)
{
return append(arr, xlen(arr));
}
bool LSPString::append(const lsp_wchar_t *arr, size_t n)
{
if (!cap_grow(n))
return false;
xmove(&pData[nLength], arr, n);
nLength += n;
nHash = 0;
return true;
}
bool LSPString::append_ascii(const char *arr, size_t n)
{
if (!cap_grow(n))
return false;
acopy(&pData[nLength], arr, n);
nLength += n;
nHash = 0;
return true;
}
bool LSPString::append_utf8(const char *arr, size_t n)
{
if (nLength <= 0)
return set_utf8(arr, n);
LSPString tmp;
if (!tmp.set_utf8(arr, n))
return false;
return append(&tmp);
}
bool LSPString::append_utf16(const lsp_utf16_t *arr, size_t n)
{
if (nLength <= 0)
return set_utf16(arr, n);
LSPString tmp;
if (!tmp.set_utf16(arr, n))
return false;
return append(&tmp);
}
bool LSPString::append_utf16(const lsp_utf16_t *arr)
{
return append_utf16(arr, u16len(arr));
}
bool LSPString::append(const LSPString *src)
{
if (src->nLength <= 0)
return true;
if (!cap_grow(src->nLength))
return false;
xmove(&pData[nLength], src->pData, src->nLength);
nLength += src->nLength;
nHash = 0;
return true;
}
bool LSPString::append(const LSPString *src, ssize_t first)
{
XSAFE_TRANS(first, src->nLength, false);
ssize_t length = src->nLength - first;
if (length <= 0)
return true;
if (!cap_grow(length))
return false;
xmove(&pData[nLength], &src->pData[first], length);
nLength += length;
nHash = 0;
return true;
}
bool LSPString::append(const LSPString *src, ssize_t first, ssize_t last)
{
XSAFE_TRANS(first, src->nLength, false);
XSAFE_TRANS(last, src->nLength, false);
ssize_t length = last - first;
if (length <= 0)
return true;
if (!cap_grow(length))
return false;
xmove(&pData[nLength], &src->pData[first], length);
nLength += length;
nHash = 0;
return true;
}
bool LSPString::prepend(lsp_wchar_t ch)
{
if (!cap_grow(1))
return false;
if (nLength > 0)
xmove(&pData[1], pData, nLength);
pData[0] = ch;
nLength ++;
nHash = 0;
return true;
}
bool LSPString::prepend(const lsp_wchar_t *arr, size_t n)
{
if (n <= 0)
return true;
if (!cap_grow(n))
return false;
if (nLength > 0)
xmove(&pData[n], pData, nLength);
xmove(pData, arr, n);
nLength += n;
nHash = 0;
return true;
}
bool LSPString::prepend_ascii(const char *arr, size_t n)
{
if (n <= 0)
return true;
if (!cap_grow(n))
return false;
if (nLength > 0)
xmove(&pData[n], pData, nLength);
acopy(pData, arr, n);
nLength += n;
nHash = 0;
return true;
}
bool LSPString::prepend_utf8(const char *arr, size_t n)
{
if (nLength <= 0)
return set_utf8(arr, n);
LSPString tmp;
if (!tmp.set_utf8(arr, n))
return false;
return prepend(&tmp);
}
bool LSPString::prepend(const LSPString *src)
{
if (src->nLength <= 0)
return true;
if (!cap_grow(src->nLength))
return false;
if (nLength > 0)
xmove(&pData[src->nLength], pData, nLength);
xmove(pData, src->pData, src->nLength);
nLength += src->nLength;
nHash = 0;
return true;
}
bool LSPString::prepend(const LSPString *src, ssize_t first)
{
XSAFE_TRANS(first, src->nLength, false);
ssize_t length = src->nLength - first;
if (length <= 0)
return true;
if (!cap_grow(length))
return false;
if (nLength > 0)
xmove(&pData[length], pData, nLength);
xmove(pData, &src->pData[first], length);
nLength += length;
nHash = 0;
return true;
}
bool LSPString::prepend(const LSPString *src, ssize_t first, ssize_t last)
{
XSAFE_TRANS(first, src->nLength, false);
XSAFE_TRANS(last, src->nLength, false);
ssize_t length = last - first;
if (length <= 0)
return true;
if (!cap_grow(length))
return false;
if (nLength > 0)
xmove(&pData[length], pData, nLength);
xmove(pData, &src->pData[first], length);
nLength += length;
nHash = 0;
return true;
}
bool LSPString::ends_with(lsp_wchar_t ch) const
{
return (nLength > 0) ? pData[nLength-1] == ch : false;
}
bool LSPString::ends_with_nocase(lsp_wchar_t ch) const
{
if (nLength <= 0)
return false;
return lsp::to_lower(pData[nLength-1]) == lsp::to_lower(ch);
}
bool LSPString::ends_with(const LSPString *src) const
{
if (src->nLength <= 0)
return true;
ssize_t offset = nLength - src->nLength;
if (offset < 0)
return false;
return xcmp(&pData[offset], src->pData, src->nLength) == 0;
}
bool LSPString::ends_with_ascii(const char *src) const
{
size_t len = strlen(src);
return (len <= nLength) ? starts_with_ascii(src, nLength - len) : false;
}
bool LSPString::ends_with_ascii_nocase(const char *src) const
{
size_t len = strlen(src);
return (len <= nLength) ? starts_with_ascii_nocase(src, nLength - len) : false;
}
bool LSPString::ends_with_nocase(const LSPString *src) const
{
if (src->nLength <= 0)
return true;
ssize_t offset = nLength - src->nLength;
if (offset < 0)
return false;
return xcasecmp(&pData[offset], src->pData, src->nLength) == 0;
}
bool LSPString::starts_with(lsp_wchar_t ch, size_t offset) const
{
return (offset < nLength) ? pData[offset] == ch : false;
}
bool LSPString::starts_with_nocase(lsp_wchar_t ch, size_t offset) const
{
if (offset > nLength)
return false;
return lsp::to_lower(pData[offset]) == lsp::to_lower(ch);
}
bool LSPString::starts_with(const LSPString *src, size_t offset) const
{
if (src->nLength <= 0)
return true;
if (nLength < (src->nLength + offset))
return false;
return xcmp(&pData[offset], src->pData, src->nLength) == 0;
}
bool LSPString::starts_with_ascii(const char *str, size_t offset) const
{
if (offset > nLength)
return false;
for (size_t i=offset, n=nLength; (i < n); ++i)
{
lsp_wchar_t c = uint8_t(*(str++));
if (c == 0)
return true;
else if (c != pData[i])
return false;
}
return (*str == '\0');
}
bool LSPString::starts_with_nocase(const LSPString *src, size_t offset) const
{
if (src->nLength <= 0)
return true;
if (nLength < (offset + src->nLength))
return false;
return xcasecmp(&pData[offset], src->pData, src->nLength) == 0;
}
bool LSPString::starts_with_ascii_nocase(const char *str, size_t offset) const
{
if (offset > nLength)
return false;
for (size_t i=offset, n=nLength; (i < n); ++i)
{
lsp_wchar_t c = uint8_t(*(str++));
if (c == 0)
return true;
else if (lsp::to_lower(c) != lsp::to_lower(pData[i]))
return false;
}
return (*str == '\0');
}
bool LSPString::remove()
{
drop_temp();
nLength = 0;
nHash = 0;
return true;
}
bool LSPString::remove(ssize_t first)
{
XSAFE_TRANS(first, nLength, false);
nLength = first;
nHash = 0;
return true;
}
bool LSPString::remove(ssize_t first, ssize_t last)
{
XSAFE_TRANS(first, nLength, false);
XSAFE_TRANS(last, nLength, false);
ssize_t length = last - first;
if (length <= 0)
return true;
ssize_t count = nLength - last;
if (count > 0)
xmove(&pData[first], &pData[last], count);
nLength -= length;
nHash = 0;
return true;
}
bool LSPString::remove_last()
{
if (nLength <= 0)
return false;
--nLength;
nHash = 0;
return true;
}
void LSPString::reverse()
{
drop_temp();
nHash = 0;
size_t n = (nLength >> 1);
lsp_wchar_t *h = pData, *t = &pData[nLength];
while (n--)
{
lsp_wchar_t c = *h;
*(h++) = *(--t);
*t = c;
}
}
void LSPString::shuffle()
{
if (nLength < 2)
return;
nHash = 0;
size_t n = nLength * 2;
size_t idx1 = rand() % nLength, idx2;
while (n--)
{
// Generate random indexes
idx1 = (idx1 + rand()) % nLength;
idx2 = (idx1 + rand()) % nLength;
if (idx1 == idx2)
continue;
// Swap characters
lsp_wchar_t c = pData[idx1];
pData[idx1] = pData[idx2];
pData[idx2] = c;
}
}
bool LSPString::replace(ssize_t pos, lsp_wchar_t ch)
{
XSAFE_TRANS(pos, nLength, false);
if (size_t(pos) < nLength)
{
pData[pos] = ch;
nLength = pos;
nHash = 0;
return true;
}
// Append at the tail
return append(ch);
}
bool LSPString::replace(ssize_t pos, const lsp_wchar_t *arr, size_t n)
{
XSAFE_TRANS(pos, nLength, false);
if (!cap_reserve(pos + n))
return false;
xmove(&pData[pos], arr, n);
nLength = pos + n;
nHash = 0;
return true;
}
bool LSPString::replace(ssize_t pos, const LSPString *src)
{
XSAFE_TRANS(pos, nLength, false);
if (!cap_reserve(pos + src->nLength))
return false;
xmove(&pData[pos], src->pData, src->nLength);
nLength = pos + src->nLength;
nHash = 0;
return true;
}
bool LSPString::replace(ssize_t pos, const LSPString *src, ssize_t first)
{
XSAFE_TRANS(pos, nLength, false);
XSAFE_TRANS(first, src->nLength, false);
ssize_t length = src->nLength - first;
if (length > 0)
{
if (!cap_reserve(pos + length))
return false;
xmove(&pData[pos], &src->pData[first], length);
}
nLength = pos + length;
nHash = 0;
return true;
}
bool LSPString::replace(ssize_t pos, const LSPString *src, ssize_t first, ssize_t last)
{
XSAFE_TRANS(pos, nLength, false);
XSAFE_TRANS(first, src->nLength, false);
XSAFE_TRANS(last, src->nLength, false);
ssize_t length = lsp_max(last - first, 0);
if (length > 0)
{
if (!cap_reserve(pos + length))
return false;
xmove(&pData[pos], &src->pData[first], length);
}
nLength = pos + length;
nHash = 0;
return true;
}
bool LSPString::replace(ssize_t first, ssize_t last, lsp_wchar_t ch)
{
XSAFE_TRANS(first, nLength, false);
XSAFE_TRANS(last, nLength, false);
ssize_t count = last - first;
if (count < 0)
count = 0;
if (!cap_reserve(nLength - count + 1))
return false;
ssize_t tail = nLength - first - count;
if (tail > 0)
xmove(&pData[first + 1], &pData[tail], nLength - tail);
pData[first] = ch;
nLength = nLength - count + 1;
nHash = 0;
return true;
}
bool LSPString::replace(ssize_t first, ssize_t last, const lsp_wchar_t *arr, size_t n)
{
XSAFE_TRANS(first, nLength, false);
XSAFE_TRANS(last, nLength, false);
ssize_t count = lsp_max(last - first, 0);
if (!cap_reserve(nLength - count + n))
return false;
ssize_t tail = nLength - first - count;
if (tail > 0)
xmove(&pData[first + n], &pData[tail], nLength - tail);
if (n > 0)
xmove(&pData[first], arr, n);
nLength = nLength - count + n;
nHash = 0;
return true;
}
bool LSPString::replace(ssize_t first, ssize_t last, const LSPString *src)
{
XSAFE_TRANS(first, nLength, false);
XSAFE_TRANS(last, nLength, false);
ssize_t count = lsp_max(last - first, 0);
if (!cap_reserve(nLength - count + src->nLength))
return false;
ssize_t tail = nLength - first - count;
if (tail > 0)
xmove(&pData[first + src->nLength], &pData[tail], nLength - tail);
if (src->nLength > 0)
xmove(&pData[first], src->pData, src->nLength);
nLength = nLength - count + src->nLength;
nHash = 0;
return true;
}
bool LSPString::replace(ssize_t first, ssize_t last, const LSPString *src, ssize_t sfirst)
{
XSAFE_TRANS(first, nLength, false);
XSAFE_TRANS(last, nLength, false);
ssize_t count = last - first;
if (count < 0)
count = 0;
XSAFE_TRANS(sfirst, src->nLength, false);
ssize_t scount = src->nLength - sfirst;
if (!cap_reserve(nLength - count + scount))
return false;
ssize_t tail = nLength - first - count;
if (tail > 0)
xmove(&pData[first + scount], &pData[tail], nLength - tail);
if (scount > 0)
xmove(&pData[first], &src->pData[sfirst], scount);
nLength = nLength - count + scount;
nHash = 0;
return true;
}
bool LSPString::replace(ssize_t first, ssize_t last, const LSPString *src, ssize_t sfirst, ssize_t slast)
{
XSAFE_TRANS(first, nLength, false);
XSAFE_TRANS(last, nLength, false);
ssize_t count = lsp_max(last - first, 0);
XSAFE_TRANS(sfirst, src->nLength, false);
XSAFE_TRANS(slast, src->nLength, false);
ssize_t scount = lsp_max(slast - sfirst, 0);
if (!cap_reserve(nLength - count + scount))
return false;
ssize_t tail = nLength - first - count;
if (tail > 0)
xmove(&pData[first + scount], &pData[tail], nLength - tail);
if (scount > 0)
xmove(&pData[first], &src->pData[sfirst], scount);
nLength = nLength - count + scount;
nHash = 0;
return true;
}
size_t LSPString::replace_all(lsp_wchar_t ch, lsp_wchar_t rep)
{
size_t n = 0;
for (size_t i=0; i 0)
nHash = 0;
return n;
}
ssize_t LSPString::index_of(ssize_t start, const LSPString *str) const
{
XSAFE_TRANS(start, nLength, -1);
if (str->nLength <= 0)
return start;
ssize_t last = nLength - str->nLength;
while (start <= last)
{
if (xcmp(&pData[start], str->pData, str->nLength) == 0)
return start;
start ++;
}
return -1;
}
ssize_t LSPString::index_of(const LSPString *str) const
{
if (str->nLength <= 0)
return 0;
ssize_t start = 0, last = nLength - str->nLength;
while (start <= last)
{
if (xcmp(&pData[start], str->pData, str->nLength) == 0)
return start;
start ++;
}
return -1;
}
ssize_t LSPString::index_of(ssize_t start, lsp_wchar_t ch) const
{
XSAFE_TRANS(start, nLength, -1);
ssize_t length = nLength;
while (start < length)
{
if (pData[start] == ch)
return start;
start ++;
}
return -1;
}
ssize_t LSPString::index_of(lsp_wchar_t ch) const
{
for (size_t start = 0; start < nLength; ++start)
{
if (pData[start] == ch)
return start;
}
return -1;
}
ssize_t LSPString::rindex_of(ssize_t start, const LSPString *str) const
{
if (start > ssize_t(nLength))
return -1;
start -= str->nLength;
while (start >= 0)
{
if (xcmp(&pData[start], str->pData, str->nLength) == 0)
return start;
start --;
}
return -1;
}
ssize_t LSPString::rindex_of(const LSPString *str) const
{
if (str->nLength <= 0)
return 0;
ssize_t start = nLength - str->nLength;
while (start >= 0)
{
if (xcmp(&pData[start], str->pData, str->nLength) == 0)
return start;
start --;
}
return -1;
}
ssize_t LSPString::rindex_of(ssize_t start, lsp_wchar_t ch) const
{
XSAFE_ITRANS(start, nLength, -1);
while (start >= 0)
{
if (pData[start] == ch)
return start;
start --;
}
return -1;
}
ssize_t LSPString::rindex_of(lsp_wchar_t ch) const
{
for (ssize_t start=nLength-1; start >= 0; --start)
{
if (pData[start] == ch)
return start;
}
return -1;
}
ssize_t LSPString::index_of_nocase(ssize_t start, const LSPString *str) const
{
XSAFE_TRANS(start, nLength, -1);
if (str->nLength <= 0)
return start;
ssize_t last = nLength - str->nLength;
while (start <= last)
{
if (xcasecmp(&pData[start], str->pData, str->nLength) == 0)
return start;
start ++;
}
return -1;
}
ssize_t LSPString::index_of_nocase(const LSPString *str) const
{
if (str->nLength <= 0)
return 0;
ssize_t start = 0, last = nLength - str->nLength;
while (start <= last)
{
if (xcasecmp(&pData[start], str->pData, str->nLength) == 0)
return start;
start ++;
}
return -1;
}
ssize_t LSPString::index_of_nocase(ssize_t start, lsp_wchar_t ch) const
{
XSAFE_TRANS(start, nLength, -1);
ssize_t length = nLength;
ch = lsp::to_lower(ch);
while (start < length)
{
if (lsp::to_lower(pData[start]) == ch)
return start;
start ++;
}
return -1;
}
ssize_t LSPString::index_of_nocase(lsp_wchar_t ch) const
{
ch = lsp::to_lower(ch);
for (size_t start = 0; start < nLength; ++start)
{
if (lsp::to_lower(pData[start]) == ch)
return start;
}
return -1;
}
ssize_t LSPString::rindex_of_nocase(ssize_t start, const LSPString *str) const
{
if (start > ssize_t(nLength))
return -1;
start -= str->nLength;
while (start >= 0)
{
if (xcasecmp(&pData[start], str->pData, str->nLength) == 0)
return start;
start --;
}
return -1;
}
ssize_t LSPString::rindex_of_nocase(const LSPString *str) const
{
if (str->nLength <= 0)
return 0;
ssize_t start = nLength - str->nLength;
while (start >= 0)
{
if (xcasecmp(&pData[start], str->pData, str->nLength) == 0)
return start;
start --;
}
return -1;
}
ssize_t LSPString::rindex_of_nocase(ssize_t start, lsp_wchar_t ch) const
{
XSAFE_ITRANS(start, nLength, -1);
ch = lsp::to_lower(ch);
while (start >= 0)
{
if (lsp::to_lower(pData[start]) == ch)
return start;
start --;
}
return -1;
}
ssize_t LSPString::rindex_of_nocase(lsp_wchar_t ch) const
{
ch = lsp::to_lower(ch);
for (ssize_t start=nLength-1; start >= 0; --start)
{
if (lsp::to_lower(pData[start]) == ch)
return start;
}
return -1;
}
LSPString *LSPString::substring(ssize_t first) const
{
XSAFE_TRANS(first, nLength, NULL);
ssize_t length = nLength - first;
LSPString *s = new LSPString();
if (s == NULL)
return s;
s->nLength = length;
s->nCapacity = length;
if (length > 0)
{
s->pData = xmalloc(length);
if (s->pData == NULL)
{
delete s;
return NULL;
}
xmove(s->pData, &pData[first], length);
}
else
s->pData = NULL;
return s;
}
LSPString *LSPString::substring(ssize_t first, ssize_t last) const
{
XSAFE_TRANS(first, nLength, NULL);
XSAFE_TRANS(last, nLength, NULL);
ssize_t length = last - first;
if (length < 0)
length = 0;
LSPString *s = new LSPString();
if (s == NULL)
return s;
s->nLength = length;
s->nCapacity = length;
if (length > 0)
{
s->pData = xmalloc(length);
if (s->pData == NULL)
{
delete s;
return NULL;
}
xmove(s->pData, &pData[first], length);
}
else
s->pData = NULL;
return s;
}
int LSPString::compare_to(const lsp_wchar_t *src) const
{
return compare_to(src, xlen(src));
}
int LSPString::compare_to(const lsp_wchar_t *src, size_t len) const
{
ssize_t n = (nLength > len) ? len : nLength;
const lsp_wchar_t *a = pData, *b = src;
while (n--)
{
int retval = int(*(a++)) - int(*(b++));
if (retval != 0)
return retval;
}
if (a < &pData[nLength])
return int(*a);
else if (b < &src[len])
return -int(*b);
return 0;
}
int LSPString::compare_to_ascii(const char *src) const
{
size_t i=0;
for ( ; i len) ? len : nLength;
const lsp_wchar_t *a = pData, *b = src;
while (n--)
{
int retval = int(::lsp::to_lower(*(a++))) - int(::lsp::to_lower(*(b++)));
if (retval != 0)
return retval;
}
if (a < &pData[nLength])
return int(*a);
else if (b < &src[len])
return -int(*b);
return 0;
}
int LSPString::compare_to_nocase(const lsp_wchar_t *src) const
{
return compare_to_nocase(src, xlen(src));
}
int LSPString::compare_to_utf8_nocase(const char *src) const
{
LSPString tmp;
return (tmp.set_utf8(src)) ? compare_to_nocase(&tmp) : 0;
}
int LSPString::compare_to_utf16_nocase(const lsp_utf16_t *src) const
{
LSPString tmp;
return (tmp.set_utf16(src)) ? compare_to_nocase(&tmp) : 0;
}
size_t LSPString::tolower()
{
for (size_t i=0; inLength, false);
XSAFE_TRANS(last, src->nLength, false);
return equals(&src->pData[first], last - first);
}
bool LSPString::equals_nocase(const lsp_wchar_t *src, size_t len) const
{
if (nLength != len)
return false;
const lsp_wchar_t *a = pData, *b = src;
for (size_t i=nLength; i>0; --i)
{
if (lsp::to_lower(*(a++)) != lsp::to_lower(*(b++)))
return false;
}
return true;
}
bool LSPString::equals_nocase(const lsp_wchar_t *src) const
{
return equals_nocase(src, xlen(src));
}
bool LSPString::contains_at(ssize_t index, const lsp_wchar_t *src) const
{
const lsp_wchar_t *p = &pData[index];
while (*src != '\0')
{
if (size_t(++index) > nLength)
return false;
if (*(p++) != *(src++))
return false;
}
return true;
}
bool LSPString::contains_at(ssize_t index, const lsp_wchar_t *src, size_t len) const
{
if (nLength < (index + len))
return false;
const lsp_wchar_t *p = &pData[index];
for (size_t i=0; i nLength)
return false;
if (lsp_wchar_t(*(p++)) != uint8_t(*(src++)))
return false;
}
return true;
}
bool LSPString::contains_at_utf8(ssize_t index, const char *src) const
{
LSPString tmp;
return (tmp.set_utf8(src)) ? contains_at(index, &tmp) : false;
}
bool LSPString::contains_at_utf16(ssize_t index, const lsp_utf16_t *src) const
{
LSPString tmp;
return (tmp.set_utf16(src)) ? contains_at(index, &tmp) : false;
}
bool LSPString::set_utf8(const char *s, size_t n)
{
LSPString tmp;
lsp_wchar_t ch;
while (lsp_utf32_t(ch = read_utf8_streaming(&s, &n, true)) != LSP_UTF32_EOF)
{
// Append code point
if (!tmp.append(ch))
return false;
}
if (n > 0)
return false;
tmp.swap(this);
return true;
}
bool LSPString::set_utf16(const lsp_utf16_t *s)
{
return set_utf16(s, u16len(s));
}
bool LSPString::set_utf16(const lsp_utf16_t *s, size_t n)
{
LSPString tmp;
lsp_wchar_t ch;
while (lsp_utf32_t(ch = read_utf16_streaming(&s, &n, true)) != LSP_UTF32_EOF)
{
// Append code point
if (!tmp.append(ch))
return false;
}
if (n > 0)
return false;
tmp.swap(this);
return true;
}
bool LSPString::set_utf16le(const lsp_utf16_t *s)
{
return set_utf16le(s, u16len(s));
}
bool LSPString::set_utf16le(const lsp_utf16_t *s, size_t n)
{
LSPString tmp;
lsp_wchar_t ch;
while (lsp_utf32_t(ch = read_utf16le_streaming(&s, &n, true)) != LSP_UTF32_EOF)
{
// Append code point
if (!tmp.append(ch))
return false;
}
if (n > 0)
return false;
tmp.swap(this);
return true;
}
bool LSPString::set_utf16be(const lsp_utf16_t *s)
{
return set_utf16be(s, u16len(s));
}
bool LSPString::set_utf16be(const lsp_utf16_t *s, size_t n)
{
LSPString tmp;
lsp_wchar_t ch;
while (lsp_utf32_t(ch = read_utf16be_streaming(&s, &n, true)) != LSP_UTF32_EOF)
{
// Append code point
if (!tmp.append(ch))
return false;
}
if (n > 0)
return false;
tmp.swap(this);
return true;
}
#if defined(PLATFORM_WINDOWS)
bool LSPString::set_native(const char *s, size_t n, const char *charset)
{
if (s == NULL)
return false;
else if (n == 0)
{
nLength = 0;
return true;
}
// Get codepage
ssize_t cp = codepage_from_name(charset);
if (cp < 0)
return false;
// Estimate size of string in memory
ssize_t slen = multibyte_to_widechar(cp, const_cast(s), &n, NULL, NULL);
if (slen <= 0)
return false;
// Perform native -> utf-16 encoding
lsp_utf16_t *buf = reinterpret_cast(::malloc(slen * sizeof(lsp_utf16_t)));
if (buf == NULL)
return false;
size_t bytes = slen;
slen = multibyte_to_widechar(cp, const_cast(s), &n, buf, &bytes);
if (slen <= 0)
{
free(buf);
return false;
}
// Set encoded utf-16 values
bool res = set_utf16(buf, slen);
free(buf);
return res;
}
#else
bool LSPString::set_native(const char *s, size_t n, const char *charset)
{
if (s == NULL)
return false;
else if (n == 0)
{
nLength = 0;
return true;
}
char buf[BUF_SIZE];
LSPString temp;
// Open conversion
iconv_t cd = init_iconv_to_wchar_t(charset);
if (cd == iconv_t(-1))
return set_utf8(s, n);
size_t insize = n;
size_t outsize = BUF_SIZE;
char *inbuf = const_cast(s);
char *outbuf = buf;
while (insize > 0)
{
// Do the conversion
size_t nconv = iconv(cd, &inbuf, &insize, &outbuf, &outsize);
if (nconv == (size_t) -1)
{
switch (errno)
{
case E2BIG:
case EINVAL:
break;
default:
iconv_close(cd);
return false;
}
}
// Append set of converted characters to string
ssize_t n_chars = (BUF_SIZE - outsize) / sizeof(lsp_wchar_t);
if (n_chars > 0)
{
if (!temp.append(reinterpret_cast(&buf[0]), n_chars))
{
iconv_close(cd);
return false;
}
}
size_t right = n_chars * sizeof(lsp_wchar_t);
ssize_t tail = (outsize - right) % sizeof(lsp_wchar_t);
if (tail > 0)
{
// If there is a tail, copy it to the start of buffer
::memmove(buf, &buf[right], tail);
outbuf = &buf[tail];
outsize = BUF_SIZE - tail;
}
else
{
// Otherwise just reset buffer's pointer
outbuf = buf;
outsize = BUF_SIZE;
}
}
// Close descriptor
iconv_close(cd);
take(&temp);
return true;
}
#endif /* PLATFORM_WINDOWS */
bool LSPString::set_ascii(const char *s, size_t n)
{
LSPString tmp;
if (!tmp.reserve(n))
return false;
acopy(tmp.pData, s, n);
take(&tmp);
nLength = n;
nHash = 0;
return true;
}
const char *LSPString::get_utf8(ssize_t first, ssize_t last) const
{
XSAFE_TRANS(first, nLength, NULL);
XSAFE_TRANS(last, nLength, NULL);
if (first > last)
return NULL;
if (pTemp != NULL)
pTemp->nOffset = 0;
char temp[BUF_SIZE + 16];
char *th = temp, *tt = &temp[BUF_SIZE];
for (ssize_t i=first; i= tt)
{
if (!append_temp(temp, th - temp))
return NULL;
th = temp;
}
}
*(th++) = '\0';
if (!append_temp(temp, th - temp))
return NULL;
return pTemp->pData;
}
const lsp_utf16_t *LSPString::get_utf16(ssize_t first, ssize_t last) const
{
XSAFE_TRANS(first, nLength, NULL);
XSAFE_TRANS(last, nLength, NULL);
if (first > last)
return NULL;
if (pTemp != NULL)
pTemp->nOffset = 0;
lsp_utf16_t temp[BUF_SIZE + 8];
lsp_utf16_t *th = temp, *tt = &temp[BUF_SIZE];
for (ssize_t i=first; i= tt)
{
if (!append_temp(reinterpret_cast(temp), (th - temp) * sizeof(lsp_utf16_t)))
return NULL;
th = temp;
}
}
*(th++) = '\0';
if (!append_temp(reinterpret_cast(temp), (th - temp) * sizeof(lsp_utf16_t)))
return NULL;
return reinterpret_cast(pTemp->pData);
}
const lsp_utf16_t *LSPString::get_utf16le(ssize_t first, ssize_t last) const
{
XSAFE_TRANS(first, nLength, NULL);
XSAFE_TRANS(last, nLength, NULL);
if (first > last)
return NULL;
if (pTemp != NULL)
pTemp->nOffset = 0;
lsp_utf16_t temp[BUF_SIZE + 8];
lsp_utf16_t *th = temp, *tt = &temp[BUF_SIZE];
for (ssize_t i=first; i= tt)
{
if (!append_temp(reinterpret_cast(temp), (th - temp) * sizeof(lsp_utf16_t)))
return NULL;
th = temp;
}
}
*(th++) = '\0';
if (!append_temp(reinterpret_cast(temp), (th - temp) * sizeof(lsp_utf16_t)))
return NULL;
return reinterpret_cast(pTemp->pData);
}
const lsp_utf16_t *LSPString::get_utf16be(ssize_t first, ssize_t last) const
{
XSAFE_TRANS(first, nLength, NULL);
XSAFE_TRANS(last, nLength, NULL);
if (first > last)
return NULL;
if (pTemp != NULL)
pTemp->nOffset = 0;
lsp_utf16_t temp[BUF_SIZE + 8];
lsp_utf16_t *th = temp, *tt = &temp[BUF_SIZE];
for (ssize_t i=first; i= tt)
{
if (!append_temp(reinterpret_cast(temp), (th - temp) * sizeof(lsp_utf16_t)))
return NULL;
th = temp;
}
}
*(th++) = '\0';
if (!append_temp(reinterpret_cast(temp), (th - temp) * sizeof(lsp_utf16_t)))
return NULL;
return reinterpret_cast(pTemp->pData);
}
const char *LSPString::get_ascii(ssize_t first, ssize_t last) const
{
XSAFE_TRANS(first, nLength, NULL);
XSAFE_TRANS(last, nLength, NULL);
if (first > last)
return NULL;
if (!resize_temp(last - first + 1))
return NULL;
lsp_wchar_t *p = &pData[first];
char *dst = pTemp->pData;
for (; first < last; ++first)
{
lsp_wchar_t c = *(p++);
*(dst++) = (c <= 0x7f) ? c : 0xff;
}
*(dst++) = '\0';
pTemp->nOffset = dst - pTemp->pData;
return pTemp->pData;
}
#if defined(PLATFORM_WINDOWS)
const char *LSPString::get_native(ssize_t first, ssize_t last, const char *charset) const
{
XSAFE_TRANS(first, nLength, NULL);
XSAFE_TRANS(last, nLength, NULL);
ssize_t length = last - first;
if (length < 0)
return NULL;
else if (length == 0)
return "";
// Get codepage
ssize_t cp = codepage_from_name(charset);
if (cp < 0)
return NULL;
// Estimate number of bytes required
lsp_utf16_t *buf = const_cast(get_utf16(first, last));
if (buf == NULL)
return NULL;
lsp_finally{ free(buf); };
// Drop temporary data because it is stored in buf variable and can not be reused
pTemp->pData = NULL;
pTemp->nLength = 0;
pTemp->nOffset = 0;
size_t slen = length;
ssize_t res = widechar_to_multibyte(cp, buf, &slen, NULL, NULL) + 4; // + terminating 0
if ((res <= 0) || (!resize_temp(res)))
return NULL;
// We have enough space for saving data
size_t n = res;
res = widechar_to_multibyte(cp, buf, &slen, pTemp->pData, &n);
if (res <= 0)
return NULL;
// Append terminating zero
pTemp->pData[res++] = '\0';
pTemp->pData[res++] = '\0';
pTemp->pData[res++] = '\0';
pTemp->pData[res++] = '\0';
pTemp->nOffset = res;
return pTemp->pData;
}
#else
const char *LSPString::get_native(ssize_t first, ssize_t last, const char *charset) const
{
XSAFE_TRANS(first, nLength, NULL);
XSAFE_TRANS(last, nLength, NULL);
if (first > last)
return NULL;
// Open conversion
iconv_t cd = init_iconv_from_wchar_t(charset);
if (cd == iconv_t(-1))
return get_utf8(first, last);
// Analyze temp
size_t outsize = 0;
char *outbuf = NULL;
if (pTemp != NULL)
{
pTemp->nOffset = 0;
outsize = pTemp->nLength;
outbuf = pTemp->pData;
}
size_t insize = (last - first) * sizeof(lsp_wchar_t);
char *inbuf = reinterpret_cast(const_cast(&pData[first]));
while (insize > 0)
{
// Reserve space if there is not enough space
if (outsize < 16)
{
// Try to grow the temprary buffer
if (!grow_temp(BUF_SIZE))
{
iconv_close(cd);
return NULL;
}
// Initialize location of buffers to store data
outsize = pTemp->nLength - pTemp->nOffset;
outbuf = &pTemp->pData[pTemp->nOffset];
}
// Do the conversion
size_t nconv = iconv(cd, &inbuf, &insize, &outbuf, &outsize);
if (nconv == (size_t) -1)
{
int err_code = errno;
switch (err_code)
{
case E2BIG:
case EINVAL:
break;
default:
iconv_close (cd);
return NULL;
}
}
// Update pointer
pTemp->nOffset = pTemp->nLength - outsize;
}
// Close the iconv descriptor
iconv_close(cd);
// Append zeros at the end to make compatible with C-strings
if (!append_temp("\x00\x00\x00\x00", 4))
return NULL;
return pTemp->pData;
}
#endif /* PLATFORM_WINDOWS */
size_t LSPString::match(const LSPString *s, size_t index) const
{
if (index >= nLength)
return 0;
size_t i=0, n = lsp_min(s->nLength, nLength - index);
for (; i < n; ++i)
{
if (pData[i] != s->pData[i])
return i;
}
return i;
}
size_t LSPString::match_nocase(const LSPString *s, size_t index) const
{
if (index >= nLength)
return 0;
size_t i=0, n = lsp_min(s->nLength, nLength - index);
for (; i < n; ++i)
{
if (lsp::to_lower(pData[i]) != lsp::to_lower(s->pData[i]))
return i;
}
return i;
}
char *LSPString::clone_utf8(size_t *bytes, ssize_t first, ssize_t last) const
{
const char *utf8 = get_utf8(first, last);
if (utf8 == NULL)
return NULL;
size_t offset = (pTemp != NULL) ? pTemp->nOffset : 0;
char *ptr = reinterpret_cast(lsp::memdup(utf8, offset));
if (bytes != NULL)
*bytes = (ptr != NULL) ? offset : 0;
return ptr;
}
lsp_utf16_t *LSPString::clone_utf16(size_t *bytes, ssize_t first, ssize_t last) const
{
const lsp_utf16_t *utf16 = get_utf16(first, last);
if (utf16 == NULL)
return NULL;
size_t offset = (pTemp != NULL) ? pTemp->nOffset : 0;
lsp_utf16_t *ptr = reinterpret_cast(lsp::memdup(utf16, offset));
if (bytes != NULL)
*bytes = (ptr != NULL) ? offset : 0;
return ptr;
}
lsp_utf16_t *LSPString::clone_utf16le(size_t *bytes, ssize_t first, ssize_t last) const
{
const lsp_utf16_t *utf16 = get_utf16le(first, last);
if (utf16 == NULL)
return NULL;
size_t offset = (pTemp != NULL) ? pTemp->nOffset : 0;
lsp_utf16_t *ptr = reinterpret_cast(lsp::memdup(utf16, offset));
if (bytes != NULL)
*bytes = (ptr != NULL) ? offset : 0;
return ptr;
}
lsp_utf16_t *LSPString::clone_utf16be(size_t *bytes, ssize_t first, ssize_t last) const
{
const lsp_utf16_t *utf16 = get_utf16be(first, last);
if (utf16 == NULL)
return NULL;
size_t offset = (pTemp != NULL) ? pTemp->nOffset : 0;
lsp_utf16_t *ptr = reinterpret_cast(lsp::memdup(utf16, offset));
if (bytes != NULL)
*bytes = (ptr != NULL) ? offset : 0;
return ptr;
}
char *LSPString::clone_ascii(size_t *bytes, ssize_t first, ssize_t last) const
{
const char *ascii = get_ascii(first, last);
if (ascii == NULL)
return NULL;
size_t offset = (pTemp != NULL) ? pTemp->nOffset : 0;
char *ptr = reinterpret_cast(lsp::memdup(ascii, offset));
if (bytes != NULL)
*bytes = (ptr != NULL) ? offset : 0;
return ptr;
}
char *LSPString::clone_native(size_t *bytes, ssize_t first, ssize_t last, const char *charset) const
{
const char *native = get_native(first, last, charset);
if (native == NULL)
return NULL;
size_t offset = (pTemp != NULL) ? pTemp->nOffset : 0;
char *ptr = reinterpret_cast(lsp::memdup(native, offset));
if (bytes != NULL)
*bytes = (ptr != NULL) ? offset : 0;
return ptr;
}
bool LSPString::append_temp(const char *p, size_t n) const
{
ssize_t free = (pTemp != NULL) ? pTemp->nLength - pTemp->nOffset : -1;
if (free < ssize_t(n))
{
size_t resize = n + (n >> 1);
if (pTemp != NULL)
resize += pTemp->nLength;
if (!resize_temp(resize))
return false;
}
memcpy(&pTemp->pData[pTemp->nOffset], p, n * sizeof(char));
pTemp->nOffset += n;
return true;
}
bool LSPString::grow_temp(size_t n) const
{
if (pTemp == NULL)
{
pTemp = static_cast(malloc(sizeof(buffer_t)));
if (pTemp == NULL)
return false;
pTemp->nLength = 0;
pTemp->nOffset = 0;
pTemp->pData = 0;
}
char *xc = static_cast(realloc(pTemp->pData, (pTemp->nLength + n)*sizeof(char)));
if (xc == NULL)
return false;
pTemp->pData = xc;
pTemp->nLength += n;
return true;
}
bool LSPString::resize_temp(size_t n) const
{
if (pTemp == NULL)
{
pTemp = static_cast(malloc(sizeof(buffer_t)));
if (pTemp == NULL)
return false;
pTemp->nLength = 0;
pTemp->nOffset = 0;
pTemp->pData = 0;
}
char *xc = static_cast(realloc(pTemp->pData, n*sizeof(char)));
if (xc == NULL)
return false;
pTemp->pData = xc;
pTemp->nLength = n;
return true;
}
size_t LSPString::count(lsp_wchar_t ch) const
{
size_t n = 0;
for (size_t i=0; i 0)
{
// Find the occurrence
for (blk = src-1; blk > pData; --blk)
{
if (*blk != '\n')
continue;
if (blk[-1] != '\r')
break;
}
// blk now points at the block before the '\r' symbol
distance = src - blk;
dst -= distance;
if (distance > 0)
memmove(dst, blk, distance * sizeof(lsp_wchar_t));
src = blk;
*(--dst) = '\r';
}
return true;
}
bool LSPString::to_unix()
{
// Step 1: estimate the number of unprocessed line endings
size_t count = 0;
for (size_t i=1; i 0)
{
// Find the occurrence
for (blk = src + 1; blk < end; ++blk)
{
if (*blk != '\n')
continue;
if ((blk > pData) && (blk[-1] == '\r'))
break;
}
// blk now points at the end of block before the '\r' symbol
distance = blk - src - 1;
if ((distance > 0) && (src != dst))
memmove(dst, src, distance * sizeof(lsp_wchar_t));
src += distance + 1;
dst += distance;
}
// move the rest data
if (src < end)
memmove(dst, src, (end - src) * sizeof(lsp_wchar_t));
return true;
}
namespace lltl
{
size_t hash_spec::hash_func(const void *ptr, size_t size)
{
return (static_cast(ptr))->hash();
}
ssize_t compare_spec::cmp_func(const void *a, const void *b, size_t size)
{
const LSPString *sa = static_cast(a);
const LSPString *sb = static_cast(b);
return sa->compare_to(sb);
}
void *allocator_spec::clone_func(const void *src, size_t size)
{
return (static_cast(src))->clone();
}
void allocator_spec::free_func(void *ptr)
{
delete (static_cast(ptr));
}
}
} /* namespace lsp */