size_t arg_length = ALIGN_SIZE(length + 1);

assert(arg_length > length);

if (arg_length <= length) return true; /* Overflow */

m_length = 0;

if (m_alloced_length < arg_length) {

mem_free();

if (!(m_ptr = static_cast<char *>(

my_malloc(STRING_PSI_MEMORY_KEY, arg_length, MYF(MY_WME)))))

return true;

m_alloced_length = static_cast<uint32>(arg_length);

m_is_alloced = true;

}

m_ptr[0] = 0;

return false;

size_t len = ALIGN_SIZE(alloc_length + 1);

assert(len > alloc_length);

if (len <= alloc_length) return true; /* Overflow */

if (force_on_heap && !m_is_alloced) {

/*

m_alloced_length = 0;

}

if (m_alloced_length < len) { // Available bytes are not enough.

// Signal an error if len exceeds uint32 max on 64-bit word platform.

#if defined(__WORDSIZE) && (__WORDSIZE == 64)

if (len > std::numeric_limits<uint32>::max()) return true;

#endif

char *new_ptr;

if (m_is_alloced) {

if (!(new_ptr = static_cast<char *>(

my_realloc(STRING_PSI_MEMORY_KEY, m_ptr, len, MYF(MY_WME)))))

return true; // Signal error

} else if ((new_ptr = static_cast<char *>(

my_malloc(STRING_PSI_MEMORY_KEY, len, MYF(MY_WME))))) {

if (m_length > len - 1) m_length = 0;

if (m_length > 0) memcpy(new_ptr, m_ptr, m_length);

new_ptr[m_length] = 0;

m_is_alloced = true;

} else

return true; // Signal error

m_ptr = new_ptr;

m_alloced_length = static_cast<uint32>(len);

}

m_ptr[alloc_length] = 0; // This make other funcs shorter

return false;

const size_t len = ALIGN_SIZE(sz + 1);

const size_t ret =

(m_is_alloced && m_alloced_length < len) ? sz + (m_length / 4) : sz;

return ret;

if (mem_realloc(next_realloc_exp_size(alloc_length))) return true;

m_ptr[alloc_length] = '\0';

return false;

uint l = 20 * cs->mbmaxlen + 1;

int base = unsigned_flag ? 10 : -10;

if (alloc(l)) return true;

m_length = (uint32)(cs->cset->longlong10_to_str)(cs, m_ptr, l, base, num);

m_charset = cs;

return false;

char buff[FLOATING_POINT_BUFFER];

uint dummy_errors;

if (decimals >= DECIMAL_NOT_SPECIFIED) {

size_t len =

my_gcvt(num, MY_GCVT_ARG_DOUBLE, MAX_DOUBLE_STR_LENGTH, buff, nullptr);

return copy(buff, len, &my_charset_latin1, cs, &dummy_errors);

}

size_t len = my_fcvt(num, decimals, buff, nullptr);

return copy(buff, len, &my_charset_latin1, cs, &dummy_errors);

if (!m_is_alloced) {

m_alloced_length = 0; // Force realloc

return mem_realloc(m_length);

}

return false;

/*

if (&str == this && str.is_alloced()) return false;

/*

const size_t str_length = str.m_length;

const char *str_ptr = str.m_ptr;

if (alloc(str.m_length)) return true;

m_length = str_length;

if (m_length > 0) memmove(m_ptr, str_ptr, m_length); // May be overlapping

m_ptr[m_length] = 0;

m_charset = str.m_charset;

return false;

if (alloc(arg_length)) return true;

if ((m_length = arg_length)) memcpy(m_ptr, str, arg_length);

m_ptr[arg_length] = 0;

m_charset = cs;

return false;

const CHARSET_INFO *cs_from,

const CHARSET_INFO *cs_to) {

size_t offset;

return (needs_conversion(arg_length, cs_from, cs_to, &offset) ||

/* force conversion when storing a binary string */

(cs_from == &my_charset_bin &&

/* into a non-binary destination */

cs_to != &my_charset_bin &&

/* and any of the following is true :*/

(

/* it's a variable length encoding */

cs_to->mbminlen != cs_to->mbmaxlen ||

/* longer than 2 bytes : neither 1 byte nor ucs2 */

cs_to->mbminlen > 2 ||

/* and is not a multiple of the char byte size */

0 != (arg_length % cs_to->mbmaxlen))));

const CHARSET_INFO *cs) {

/* How many bytes are in incomplete character */

offset = cs->mbminlen - offset; /* How many zeros we should prepend */

assert(offset && offset != cs->mbminlen);

size_t aligned_length = arg_length + offset;

if (alloc(aligned_length)) return true;

/*

memset(m_ptr, 0, offset);

memcpy(m_ptr + offset, str, arg_length);

m_ptr[aligned_length] = 0;

/* m_length is always >= 0 as arg_length is != 0 */

m_length = aligned_length;

m_charset = cs;

return false;

const CHARSET_INFO *cs) {

/* How many bytes are in incomplete character */

size_t offset = (arg_length % cs->mbminlen);

if (!offset) /* All characters are complete, just copy */

{

set(str, arg_length, cs);

return false;

}

return copy_aligned(str, arg_length, offset, cs);

const CHARSET_INFO *from_cs, const CHARSET_INFO *to_cs,

uint *errors) {

size_t offset;

assert(!str || str != m_ptr);

if (!needs_conversion(arg_length, from_cs, to_cs, &offset)) {

*errors = 0;

return copy(str, arg_length, to_cs);

}

if ((from_cs == &my_charset_bin) && offset) {

*errors = 0;

return copy_aligned(str, arg_length, offset, to_cs);

}

size_t new_length = to_cs->mbmaxlen * arg_length;

if (alloc(new_length)) return true;

m_length = copy_and_convert(m_ptr, new_length, to_cs, str, arg_length,

from_cs, errors);

m_charset = to_cs;

return false;

if (m_charset->mbminlen == 1) {

set(str, arg_length, m_charset);

return false;

}

uint dummy_errors;

return copy(str, arg_length, &my_charset_latin1, m_charset, &dummy_errors);

if (m_length > max_length)

m_ptr[m_length = max_length] = 0;

else {

if (mem_realloc(max_length)) return true;

memset(m_ptr + m_length, fill_char, max_length - m_length);

m_length = max_length;

}

return false;

if (s.length()) {

assert(!this->uses_buffer_owned_by(&s));

assert(!s.uses_buffer_owned_by(this));

if (mem_realloc_exp((m_length + s.length()))) return true;

memcpy(m_ptr + m_length, s.ptr(), s.length());

m_length += s.length();

}

return false;

if (!arg_length) return false;

/*

if (m_charset->mbminlen > 1) {

size_t add_length = arg_length * m_charset->mbmaxlen;

uint dummy_errors;

if (mem_realloc(m_length + add_length)) return true;

m_length += copy_and_convert(m_ptr + m_length, add_length, m_charset, s,

arg_length, &my_charset_latin1, &dummy_errors);

return false;

}

/*

if (mem_realloc_exp(m_length + arg_length)) return true;

memcpy(m_ptr + m_length, s, arg_length);

m_length += arg_length;

return false;

if (mem_realloc_exp(m_length + MAX_BIGINT_WIDTH + 2)) return true;

char *end = longlong10_to_str(val, m_ptr + m_length, 10);

m_length = end - m_ptr;

return false;

if (mem_realloc_exp(m_length + MAX_BIGINT_WIDTH + 2))

return true; /* purecov: inspected */

char *end = longlong10_to_str(val, m_ptr + m_length, -10);

m_length = end - m_ptr;

return false;

size_t offset;

if (needs_conversion(arg_length, cs, m_charset, &offset)) {

size_t add_length;

if ((cs == &my_charset_bin) && offset) {

assert(m_charset->mbminlen > offset);

offset = m_charset->mbminlen - offset; // How many characters to pad

add_length = arg_length + offset;

if (mem_realloc_exp(m_length + add_length)) return true;

memset(m_ptr + m_length, 0, offset);

memcpy(m_ptr + m_length + offset, s, arg_length);

m_length += add_length;

return false;

}

add_length = arg_length / cs->mbminlen * m_charset->mbmaxlen;

uint dummy_errors;

if (mem_realloc_exp(m_length + add_length)) return true;

m_length += copy_and_convert(m_ptr + m_length, add_length, m_charset, s,

arg_length, cs, &dummy_errors);

} else {

if (mem_realloc_exp(m_length + arg_length)) return true;

memcpy(m_ptr + m_length, s, arg_length);

m_length += arg_length;

}

return false;

size_t full_length, char fill_char) {

size_t t_length = arg_length > full_length ? arg_length : full_length;

if (mem_realloc(m_length + t_length)) return true;

if (full_length > arg_length) {

t_length = full_length - arg_length;

memset(m_ptr + m_length, fill_char, t_length);

m_length = m_length + t_length;

}

append(s, arg_length);

return false;

if (i <= 0) return i;

return m_charset->cset->charpos(m_charset, m_ptr + offset, m_ptr + m_length,

i);

if (s.length() + offset <= m_length) {

if (!s.length()) return ((int)offset); // Empty string is always found

const char *str = m_ptr + offset;

const char *search = s.ptr();

const char *end = m_ptr + m_length - s.length() + 1;

const char *search_end = s.ptr() + s.length();

skip:

while (str != end) {

if (*str++ == *search) {

const char *i = str;

const char *j = search + 1;

while (j != search_end)

if (*i++ != *j++) goto skip;

return (int)(str - m_ptr) - 1;

}

}

}

return -1;

if (s.length() <= offset && offset <= m_length) {

if (!s.length())

return static_cast<int>(offset); // Empty string is always found

const char *str = m_ptr + offset - 1;

const char *search = s.ptr() + s.length() - 1;

const char *end = m_ptr + s.length() - 2;

const char *search_end = s.ptr() - 1;

skip:

while (str != end) {

if (*str-- == *search) {

const char *i = str;

const char *j = search - 1;

while (j != search_end)

if (*i-- != *j--) goto skip;

return (int)(i - m_ptr) + 1;

}

}

}

return -1;

int original_count = this->numchars();

if (offset > original_count) {

offset = original_count;

}

if (offset + count > original_count) {

count = original_count - offset;

}

size_t bytes_offset = this->charpos(offset);

return String(this->m_ptr + bytes_offset,

this->charpos(offset + count) - bytes_offset, this->m_charset);

size_t to_length) {

long diff = static_cast<long>(to_length) - static_cast<long>(arg_length);

if (offset + arg_length <= m_length) {

if (diff < 0) {

if (to_length) memcpy(m_ptr + offset, to, to_length);

memmove(m_ptr + offset + to_length, m_ptr + offset + arg_length,

m_length - offset - arg_length);

} else {

if (diff) {

if (mem_realloc_exp(m_length + diff)) return true;

memmove(m_ptr + offset + to_length, m_ptr + offset + arg_length,

m_length - offset - arg_length);

}

if (to_length) memcpy(m_ptr + offset, to, to_length);

}

m_length += diff;

}

return false;

if (m_alloced_length < m_length + space_needed) {

return mem_realloc(m_alloced_length + max(space_needed, grow_by) - 1);

}

return false;

char *buff = &((*str)[str->length()]);

int written = my_gcvt(d, MY_GCVT_ARG_DOUBLE, len, buff, nullptr);

str->length(str->length() + written);

return cs->coll->strnncollsp(

cs, pointer_cast<const uchar *>(s->ptr()), s->length(),

pointer_cast<const uchar *>(t->ptr()), t->length());

size_t s_len = s->length();

size_t t_len = t->length();

size_t len = min(s_len, t_len);

int cmp = (len == 0) ? 0 : memcmp(s->ptr(), t->ptr(), len);

return (cmp) ? cmp : static_cast<int>(s_len) - static_cast<int>(t_len);

size_t to_length, const CHARSET_INFO *from_cs,

const char *from, size_t from_length,

size_t nchars,

const char **well_formed_error_pos,

const char **cannot_convert_error_pos,

const char **from_end_pos) {

size_t res;

if ((to_cs == &my_charset_bin) || (from_cs == &my_charset_bin) ||

(to_cs == from_cs) || my_charset_same(from_cs, to_cs)) {

if (to_length < to_cs->mbminlen || !nchars) {

*from_end_pos = from;

*cannot_convert_error_pos = nullptr;

*well_formed_error_pos = nullptr;

return 0;

}

if (to_cs == &my_charset_bin) {

res = min(min(nchars, to_length), from_length);

memmove(to, from, res);

*from_end_pos = from + res;

*well_formed_error_pos = nullptr;

*cannot_convert_error_pos = nullptr;

} else {

int well_formed_error;

uint from_offset;

if ((from_offset = (from_length % to_cs->mbminlen)) &&

(from_cs == &my_charset_bin)) {

/*

uint pad_length = to_cs->mbminlen - from_offset;

memset(to, 0, pad_length);

memmove(to + pad_length, from, from_offset);

/*

if (to_cs->cset->well_formed_len(to_cs, to, to + to_cs->mbminlen, 1,

&well_formed_error) !=

to_cs->mbminlen) {

*from_end_pos = *well_formed_error_pos = from;

*cannot_convert_error_pos = nullptr;

return 0;

}

nchars--;

from += from_offset;

from_length -= from_offset;

to += to_cs->mbminlen;

to_length -= to_cs->mbminlen;

}

size_t min_length = min(from_length, to_length);

/*

if (to_cs->mbmaxlen > 1 && to_cs->mbmaxlen == to_cs->mbminlen)

min_length -= min_length % to_cs->mbmaxlen;

res = to_cs->cset->well_formed_len(to_cs, from, from + min_length, nchars,

&well_formed_error);

if (res > 0) memmove(to, from, res);

*from_end_pos = from + res;

/*

if (well_formed_error && to_cs->mbmaxlen > 1 &&

res > min_length - to_cs->mbmaxlen) {

const char *from_end = from + min(res + to_cs->mbmaxlen, from_length);

size_t extra = to_cs->cset->well_formed_len(

to_cs, *from_end_pos, from_end, 1, &well_formed_error);

well_formed_error = (res + extra < min_length);

}

*well_formed_error_pos = well_formed_error ? *from_end_pos : nullptr;

*cannot_convert_error_pos = nullptr;

if (from_offset) res += to_cs->mbminlen;

}

} else {

int cnvres;

my_wc_t wc;

my_charset_conv_mb_wc mb_wc = from_cs->cset->mb_wc;

my_charset_conv_wc_mb wc_mb = to_cs->cset->wc_mb;

const uchar *from_end = (const uchar *)from + from_length;

uchar *to_end = (uchar *)to + to_length;

char *to_start = to;

*well_formed_error_pos = nullptr;

*cannot_convert_error_pos = nullptr;

for (; nchars; nchars--) {

const char *from_prev = from;

if ((cnvres = (*mb_wc)(from_cs, &wc, pointer_cast<const uchar *>(from),

from_end)) > 0)

from += cnvres;

else if (cnvres == MY_CS_ILSEQ) {

if (!*well_formed_error_pos) *well_formed_error_pos = from;

from++;

wc = '?';

} else if (cnvres > MY_CS_TOOSMALL) {

/*

if (!*cannot_convert_error_pos) *cannot_convert_error_pos = from;

from += (-cnvres);

wc = '?';

} else

break; // Not enough characters

outp:

if ((cnvres = (*wc_mb)(to_cs, wc, (uchar *)to, to_end)) > 0)

to += cnvres;

else if (cnvres == MY_CS_ILUNI && wc != '?') {

if (!*cannot_convert_error_pos) *cannot_convert_error_pos = from_prev;

wc = '?';

goto outp;

} else {

from = from_prev;

break;

}

}

*from_end_pos = from;

res = to - to_start;

}

return res;

char *st = m_ptr;

char *end = st + m_length;

if (str->reserve(m_length)) return;

for (; st < end; st++) {

uchar c = *st;

switch (c) {

case '\\':

str->append(STRING_WITH_LEN("\\\\"));

break;

case '\0':

str->append(STRING_WITH_LEN("\\0"));

break;

case '\'':

str->append(STRING_WITH_LEN("\\'"));

break;

case '\n':

str->append(STRING_WITH_LEN("\\n"));

break;

case '\r':

str->append(STRING_WITH_LEN("\\r"));

break;

case '\032': // Ctrl-Z

str->append(STRING_WITH_LEN("\\Z"));

break;

default:

str->append(c);

}

}

using std::swap;

swap(m_ptr, s.m_ptr);

swap(m_length, s.m_length);

swap(m_alloced_length, s.m_alloced_length);

swap(m_is_alloced, s.m_is_alloced);

swap(m_charset, s.m_charset);