dmcallis
65a0592776
Source code drop for the Actionscript virtual machine in the Adobe Flash Player for December 2013
3065 lines
115 KiB
C++
3065 lines
115 KiB
C++
/* -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*- */
|
|
/* vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
|
|
/*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*/
|
|
|
|
#include "avmplus.h"
|
|
|
|
// This is the maximum value for the characters Left field in the
|
|
// m_bitsAndFlags field of the String instance. Strings grow by
|
|
// by doubling the available buffer size until the characters left
|
|
// exceeds the size of the field. From there on, the buffer grows
|
|
// linear. Note that this number is divided by two to make sure that
|
|
// the counter actually, spans the entire buffer area; if this would
|
|
// not be done, the calculation of characters left (using GC::Size())
|
|
// would return a wrong number.
|
|
#define TSTR_MAX_CHARSLEFT ((uint32_t)TSTR_CHARSLEFT_MASK >> TSTR_CHARSLEFT_SHIFT >> 1)
|
|
|
|
// This is the maximum value of extra bytes to allocate during a
|
|
// string concatenation operation if PleaseAlloc() fails. The number
|
|
// is quite small to not kill the app just because of a large extra
|
|
// chunk of RAM being allocated just in case there are more concatenation
|
|
// operations.
|
|
#define TSTR_MAX_LOMEM_EXTRABYTES 16384
|
|
|
|
// Never allocate dynamic strings smaller than this (in bytes)
|
|
#define TSTR_MIN_DYNAMIC_ALLOCATION 32
|
|
|
|
// in fixDependentString, don't bother going dependent->dynamic if the memory
|
|
// we would save is < this (in bytes)
|
|
#define TSTR_DEPENDENT_STRING_NUISANCE_SAVINGS int32_t(sizeof(String))
|
|
|
|
using namespace MMgc;
|
|
|
|
namespace avmplus
|
|
{
|
|
// Use this constant for 16 and 32 bit strings of zero length
|
|
// we do not want any string to contain NULL buffer pointers
|
|
union Zero
|
|
{
|
|
uint32_t u32;
|
|
wchar u16;
|
|
uint8_t u8;
|
|
char c8;
|
|
};
|
|
static const Zero k_zero = { 0 };
|
|
|
|
/////////////////////////// Helpers: Widening //////////////////////////////
|
|
|
|
REALLY_INLINE void _widen8_16(const uint8_t* src, wchar* dst, int32_t len)
|
|
{
|
|
while (len-- > 0)
|
|
*dst++ = wchar(*src++);
|
|
}
|
|
|
|
/////////////////////////// Helpers: Narrowing //////////////////////////////
|
|
|
|
REALLY_INLINE void _narrow16_8(const wchar* src, uint8_t* dst, int32_t len)
|
|
{
|
|
while (len-- > 0)
|
|
{
|
|
AvmAssert(*src <= 0xFF);
|
|
*dst++ = (uint8_t) *src++;
|
|
}
|
|
}
|
|
|
|
/////////////////////////// Helpers: Copying ///////////////////////////////
|
|
|
|
// Copy the contents of the given buffer to another buffer, given two widths.
|
|
|
|
static void* _copyBuffers(const void* src, void* dst, int32_t srcLen, String::Width srcWidth, String::Width dstWidth)
|
|
{
|
|
if (srcWidth == dstWidth)
|
|
VMPI_memcpy(dst, src, srcLen << srcWidth);
|
|
else if (srcWidth == String::k8)
|
|
_widen8_16((const uint8_t*) src, (wchar*) dst, srcLen);
|
|
else
|
|
_narrow16_8((const wchar*) src, (uint8_t*) dst, srcLen);
|
|
// return the new buffer pointer
|
|
return (char*) dst + (srcLen << dstWidth);
|
|
}
|
|
|
|
#ifdef _DEBUG
|
|
void String::verify7bit() const
|
|
{
|
|
if (!(m_bitsAndFlags & TSTR_7BIT_FLAG))
|
|
return;
|
|
|
|
if (getWidth() == k8)
|
|
{
|
|
Pointers ptrs(this);
|
|
for (int32_t i = 0; i < m_length; ++i)
|
|
{
|
|
if (ptrs.p8[i] > 127)
|
|
{
|
|
AvmAssert(!"hi bit found on string with TSTR_7BIT_FLAG set");
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AvmAssert(!"only k8 strings should set TSTR_7BIT_FLAG");
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/////////////////////////// Helper: get AvmCore /////////////////////////////
|
|
|
|
REALLY_INLINE MMgc::GC* _gc(const String* s)
|
|
{
|
|
return MMgc::GC::GetGC(s);
|
|
}
|
|
|
|
REALLY_INLINE AvmCore* _core(const String* s)
|
|
{
|
|
MMgc::GC *gc = MMgc::GC::GetGC(s);
|
|
return gc->core();
|
|
}
|
|
|
|
/////////////////////////// Helpers: templated functions /////////////////////////////
|
|
|
|
//
|
|
// use typetraits to generate a compile-time error if you attempt to use a
|
|
// non-unsigned char type as an argument to these.
|
|
//
|
|
// Note that we deliberately are using a bitwise &, not a logical && here...
|
|
// GCC 4.3 and later, with -Wlogical-op enabled, will complain about the &&
|
|
// construct with
|
|
//
|
|
// "warning: logical '&&' with non-zero constant will always evaluate as true"
|
|
//
|
|
// and since many embedders compile with warnings-as-errors enabled, this crushes
|
|
// the build. This seems like a highly questionable warning to me, but since there
|
|
// is a valid workaround, we'll go with it rather than requiring embedders to disable
|
|
// that warning.
|
|
//
|
|
#define PREVENT_SIGNED_CHAR_PTR(TYPE) \
|
|
{ \
|
|
typedef MMgc::is_same<char, uint8_t> is_char_unsigned; \
|
|
typedef MMgc::is_same<char, TYPE> is_char; \
|
|
MMGC_STATIC_ASSERT(!(is_char::value & !is_char_unsigned::value)); \
|
|
}
|
|
|
|
// apparently SunPro compiler doesn't like combining REALLY_INLINE with static functions.
|
|
template <typename STR1, typename STR2>
|
|
/*static*/ REALLY_INLINE bool equalsImpl(const STR1* str1, const STR2* str2, int32_t len)
|
|
{
|
|
PREVENT_SIGNED_CHAR_PTR(STR1)
|
|
PREVENT_SIGNED_CHAR_PTR(STR2)
|
|
|
|
for (int32_t j = 0; j < len; j++)
|
|
{
|
|
if (str1[j] != str2[j])
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// NOTE: this routine cannot use memcmp(), as the test
|
|
// ecma3/String/localeCompare_rt.as depends on the difference
|
|
// in character values, and memcmp() does not guarantee to
|
|
// return this value
|
|
|
|
// apparently SunPro compiler doesn't like combining REALLY_INLINE with static functions.
|
|
template <typename STR1, typename STR2>
|
|
/*static*/ REALLY_INLINE int32_t compareImpl(const STR1* str1, const STR2* str2, int32_t len)
|
|
{
|
|
PREVENT_SIGNED_CHAR_PTR(STR1)
|
|
PREVENT_SIGNED_CHAR_PTR(STR2)
|
|
|
|
int32_t res = 0;
|
|
while (len-- > 0 && !res)
|
|
{
|
|
res = int32_t(*str2++ - *str1++);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
// apparently SunPro compiler doesn't like combining REALLY_INLINE with static functions.
|
|
template <typename STR, typename PATTERN>
|
|
/*static*/ REALLY_INLINE int32_t indexOfImpl(const STR* str, int32_t start, int32_t right, const PATTERN* pat, int32_t patlen)
|
|
{
|
|
PREVENT_SIGNED_CHAR_PTR(STR)
|
|
PREVENT_SIGNED_CHAR_PTR(PATTERN)
|
|
AvmAssert(patlen > 0);
|
|
|
|
// even with REALLY_INLINE, some compilers will be reluctant to inline equalsImpl here,
|
|
// so we explicitly repeat the code here.
|
|
const PATTERN pat0 = pat[0];
|
|
const STR* const end = str + right;
|
|
for (const STR* probe = str + start; probe <= end; ++probe)
|
|
{
|
|
if (probe[0] == pat0)
|
|
{
|
|
for (int32_t j = 1; j < patlen; j++)
|
|
{
|
|
if (probe[j] != pat[j])
|
|
goto no_match;
|
|
}
|
|
return int32_t(uintptr_t(probe - str));
|
|
}
|
|
no_match:
|
|
// some compilers will complain about a label with no statement following,
|
|
// hence the continue
|
|
continue;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
// apparently SunPro compiler doesn't like combining REALLY_INLINE with static functions.
|
|
template <typename STR>
|
|
/*static*/ REALLY_INLINE int32_t indexOfCharCodeImpl(const STR* str, int32_t start, int32_t right, wchar c)
|
|
{
|
|
PREVENT_SIGNED_CHAR_PTR(STR)
|
|
|
|
const STR* p = str + start - 1;
|
|
const STR* const end = str + right;
|
|
while (++p <= end)
|
|
if (*p == c)
|
|
return int32_t(p - str);
|
|
|
|
return -1;
|
|
}
|
|
|
|
// apparently SunPro compiler doesn't like combining REALLY_INLINE with static functions.
|
|
template <typename STR, typename PATTERN>
|
|
/*static*/ REALLY_INLINE int32_t lastIndexOfImpl(const STR* str, int32_t const start, const PATTERN* pat, int32_t patlen)
|
|
{
|
|
PREVENT_SIGNED_CHAR_PTR(STR)
|
|
PREVENT_SIGNED_CHAR_PTR(PATTERN)
|
|
AvmAssert(patlen > 0);
|
|
AvmAssert(start >= 0);
|
|
|
|
// even with REALLY_INLINE, some compilers will be reluctant to inline equalsImpl here,
|
|
// so we explicitly repeat the code here.
|
|
const PATTERN pat0 = pat[0];
|
|
for (const STR* probe = str + start; probe >= str; --probe)
|
|
{
|
|
if (probe[0] == pat0)
|
|
{
|
|
for (int32_t j = 1; j < patlen; j++)
|
|
{
|
|
if (pat[j] != probe[j])
|
|
goto no_match;
|
|
}
|
|
return int32_t(uintptr_t(probe - str));
|
|
}
|
|
no_match:
|
|
// some compilers will complain about a label with no statement following,
|
|
// hence the continue
|
|
continue;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// apparently SunPro compiler doesn't like combining REALLY_INLINE with static functions.
|
|
template <typename STR>
|
|
/*static*/ REALLY_INLINE int32_t hashCodeImpl(const STR* str, int32_t len)
|
|
{
|
|
PREVENT_SIGNED_CHAR_PTR(STR)
|
|
|
|
// must be same signed-ness as other hashcode functions.
|
|
// experimentation shows better results from signed (vs unsigned).
|
|
int32_t hashCode = 0;
|
|
while (len--)
|
|
hashCode = (hashCode >> 28) ^ (hashCode << 4) ^ *str++;
|
|
return hashCode;
|
|
}
|
|
|
|
/*static*/ REALLY_INLINE int32_t hashCodeAddChar(int32_t hashCode, char val)
|
|
{
|
|
// must be same signed-ness as other hashcode functions.
|
|
// (match sign propagation in right-shift >> 28, for better or worse)
|
|
return ((hashCode >> 28) ^ (hashCode << 4) ^ val);
|
|
}
|
|
|
|
/*static*/ REALLY_INLINE int32_t stringLengthUInt(uint32_t value)
|
|
{
|
|
if (value < 10) return 1;
|
|
else if (value < 100) return 2;
|
|
else if (value < 1000) return 3;
|
|
else if (value < 10000) return 4;
|
|
else if (value < 100000) return 5;
|
|
else if (value < 1000000) return 6;
|
|
else if (value < 10000000) return 7;
|
|
else if (value < 100000000) return 8;
|
|
else if (value < 1000000000) return 9;
|
|
else return 10;
|
|
}
|
|
|
|
////////////////////////////// Constructors ////////////////////////////////
|
|
|
|
// ctor for a static string.
|
|
|
|
REALLY_INLINE String::String(const void* buffer, Width w, int32_t length, bool is7bit) :
|
|
#ifdef DEBUGGER
|
|
AvmPlusScriptableObject(sotString()),
|
|
#endif
|
|
m_buffer(buffer), // static data - no WB() needed
|
|
m_extra(NULL),
|
|
m_length(length),
|
|
m_bitsAndFlags(w | (kStatic << TSTR_TYPE_SHIFT) | (uint32_t(is7bit) << TSTR_7BIT_SHIFT))
|
|
{
|
|
AvmAssert(m_length >= 0);
|
|
AvmAssert((uint64_t(m_length) << getWidth()) <= 0x7FFFFFFFU);
|
|
}
|
|
|
|
// ctor for a dynamic string.
|
|
|
|
REALLY_INLINE String::String(MMgc::GC* gc, void* buffer, Width w, int32_t length, int32_t charsLeft, bool is7bit) :
|
|
#ifdef DEBUGGER
|
|
AvmPlusScriptableObject(sotString()),
|
|
m_buffer((void*)NULL),
|
|
#else
|
|
m_buffer(buffer),
|
|
#endif
|
|
m_extra(NULL),
|
|
m_length(length),
|
|
m_bitsAndFlags(w | (kDynamic << TSTR_TYPE_SHIFT) | (charsLeft << TSTR_CHARSLEFT_SHIFT) | (uint32_t(is7bit) << TSTR_7BIT_SHIFT))
|
|
{
|
|
AvmAssert(m_length >= 0);
|
|
AvmAssert((uint64_t(m_length) << getWidth()) <= 0x7FFFFFFFU);
|
|
#ifdef DEBUGGER
|
|
/*
|
|
an explicit WB is only necessary if there's the possibility of an allocation between the time
|
|
the container (String) is allocated and time we set the field. In nondebugger builds, there is no
|
|
such possibility, but in DEBUGGER builds, the superclass ctor (AvmPlusScriptableObject) can
|
|
cause an allocation if sampling is enabled. ("Icky and brittle", but that's how it is.)
|
|
*/
|
|
WB(gc, this, &this->m_buffer.pv, buffer);
|
|
#else
|
|
(void)gc;
|
|
#endif
|
|
}
|
|
|
|
// ctor for a dependent string.
|
|
|
|
REALLY_INLINE String::String(MMgc::GC* gc, Stringp master, int32_t start, int32_t length) :
|
|
#ifdef DEBUGGER
|
|
AvmPlusScriptableObject(sotString()),
|
|
#endif
|
|
m_buffer(uintptr_t(start << master->getWidth())),
|
|
#ifdef DEBUGGER
|
|
m_extra(NULL),
|
|
#else
|
|
m_extra(master),
|
|
#endif
|
|
m_length(length),
|
|
// note that we propagate TSTR_7BIT_FLAG: if the entire master is TSTR_7BIT_FLAG, then so is the dependent string.
|
|
// @todo: a dependent string could qualify for TSTR_7BIT_FLAG even if it's master is not. worth checking for?
|
|
m_bitsAndFlags((master->m_bitsAndFlags & (TSTR_WIDTH_MASK | TSTR_7BIT_FLAG)) | (kDependent << TSTR_TYPE_SHIFT))
|
|
{
|
|
AvmAssert(m_length >= 0);
|
|
AvmAssert((uint64_t(m_length) << getWidth()) <= 0x7FFFFFFFU);
|
|
#ifdef DEBUGGER
|
|
WBRC(gc, this, &this->m_extra.master, master);
|
|
#else
|
|
/*
|
|
an explicit WBRC is only necessary if there's the possibility of an allocation between the time
|
|
the container (String) is allocated and time we set the field. In nondebugger builds, there is no
|
|
such possibility, but in DEBUGGER builds, the superclass ctor (AvmPlusScriptableObject) can
|
|
cause an allocation if sampling is enabled. ("Icky and brittle", but that's how it is.)
|
|
*/
|
|
AvmAssert(master != NULL);
|
|
master->IncrementRef();
|
|
(void)gc;
|
|
#endif
|
|
}
|
|
|
|
// add a and b and check for overflow
|
|
|
|
static int32_t int32AddChecked(int32_t a, int32_t b)
|
|
{
|
|
if ((a | b) >= 0) // both nonnegative?
|
|
{
|
|
uint64_t x = uint64_t(a) + uint64_t(b);
|
|
if (x <= 0x7FFFFFFFU)
|
|
return int32_t(x);
|
|
}
|
|
GCHeap::SignalObjectTooLarge();
|
|
/*NOTREACHED*/
|
|
return 0;
|
|
}
|
|
|
|
// shift a left by b and check for overflow
|
|
|
|
static int32_t int32ShlChecked(int32_t a, int32_t b)
|
|
{
|
|
AvmAssert(b < 32); // ok for this to be DEBUG-only, the shift amounts are known constants for practical purposes
|
|
if ((a | b) >= 0) // both nonnegative?
|
|
{
|
|
uint64_t x = uint64_t(a) << uint64_t(b);
|
|
if (x <= 0x7FFFFFFFU)
|
|
return int32_t(x);
|
|
}
|
|
GCHeap::SignalObjectTooLarge();
|
|
/*NOTREACHED*/
|
|
return 0;
|
|
}
|
|
|
|
static uint32_t uint32ShlChecked(uint32_t a, uint32_t b)
|
|
{
|
|
AvmAssert(b < 32); // ok for this to be DEBUG-only, the shift amounts are known constants for practical purposes
|
|
uint64_t x = uint64_t(a) << uint64_t(b);
|
|
if (x <= 0xFFFFFFFFU)
|
|
return uint32_t(x);
|
|
GCHeap::SignalObjectTooLarge();
|
|
/*NOTREACHED*/
|
|
return 0;
|
|
}
|
|
|
|
// Private static method to create a dependent string
|
|
|
|
// in nondebug builds this is a trivial wrapper around the ctor (which is itself trivial), so REALLY_INLINE it
|
|
REALLY_INLINE /*static*/ Stringp String::createDependent(GC* gc, Stringp master, int32_t start, int32_t len)
|
|
{
|
|
AvmAssert(len >= 0);
|
|
// master cannot be a dependent string
|
|
AvmAssert(!master->isDependent());
|
|
MMGC_MEM_TAG( "Strings" );
|
|
Stringp s = new(gc, MMgc::kExact) String(gc, master, start, len);
|
|
VERIFY_7BIT(s);
|
|
return s;
|
|
}
|
|
|
|
// Private static method to create a dynamic string, given a buffer and its size in characters
|
|
|
|
/*static*/ Stringp String::createDynamic(GC* gc, const void* data, int32_t len, Width w, bool is7bit, int32_t extra)
|
|
{
|
|
AvmAssert(w != kAuto);
|
|
AvmAssert(len >= 0);
|
|
|
|
// only 8-bit strings should set the 7-bit flag
|
|
if (w != k8)
|
|
is7bit = false;
|
|
|
|
// a zero-length dynamic string is legal, but a zero-length GC allocation is not.
|
|
int32_t alloc = int32AddChecked(len, extra);
|
|
|
|
MMGC_MEM_TAG( "Strings" );
|
|
|
|
// First, use PleaseAlloc(), and if the call fails, reduce the amount of extra data
|
|
// to TSTR_MAX_EXTRA_BYTES_IN_LOW_MEMORY and do an Alloc(), which may fail.
|
|
void* buffer = gc->PleaseAlloc(int32ShlChecked(alloc, w), 0);
|
|
if (buffer == NULL)
|
|
{
|
|
if (extra > (TSTR_MAX_LOMEM_EXTRABYTES >> w))
|
|
extra = TSTR_MAX_LOMEM_EXTRABYTES >> w;
|
|
alloc = len + extra; // This is safe because the new value of 'extra' is smaller than the old, and the old was checked
|
|
buffer = gc->Alloc(alloc << w, 0); // Ditto
|
|
}
|
|
|
|
int32_t bufLen = (int32_t) (GC::Size(buffer) >> w); // Note bufLen may be larger than (alloc << w)
|
|
int32_t charsLeft = bufLen - len;
|
|
// the extra character must not exceed the available field size.
|
|
//
|
|
// ok for this to be an assertion because we will not have problems with mmgc rounding up
|
|
// to a 4KB boundary; the max chars left is about 4KB.
|
|
AvmAssert(charsLeft <= int32_t((uint32_t) TSTR_CHARSLEFT_MASK >> TSTR_CHARSLEFT_SHIFT));
|
|
|
|
Stringp s = new(gc, MMgc::kExact) String(gc, buffer, w, len, charsLeft, is7bit);
|
|
|
|
if (data != NULL && len != 0)
|
|
VMPI_memcpy(buffer, data, size_t(len << w)); // This is safe because alloc >= len and buffer size is alloc << w and that has been checked.
|
|
#ifdef _DEBUG
|
|
// Terminate string with 0 for better debugging display
|
|
if (charsLeft)
|
|
{
|
|
if (w == k8)
|
|
s->m_buffer.p8[len] = 0;
|
|
else
|
|
s->m_buffer.p16[len] = 0;
|
|
}
|
|
if (data != NULL)
|
|
{
|
|
// don't try to verify if data==null, buffer will be random! (caller will verify)
|
|
VERIFY_7BIT(s);
|
|
}
|
|
#endif
|
|
return s;
|
|
}
|
|
|
|
// Private static method to create a string, given a static buffer and its size in characters
|
|
|
|
/*static*/ Stringp String::createStatic(GC* gc, const void* data, int32_t len, Width w, bool is7bit)
|
|
{
|
|
AvmAssert(w != kAuto);
|
|
AvmAssert(len >= 0);
|
|
MMGC_MEM_TAG( "Strings" );
|
|
// only 8-bit strings should set the 7-bit flag
|
|
if (w != k8)
|
|
is7bit = false;
|
|
Stringp s = new (gc, MMgc::kExact) String(data, w, len, is7bit);
|
|
VERIFY_7BIT(s);
|
|
return s;
|
|
}
|
|
|
|
// Create a string out of an 8bit buffer. Characters are just widened and copied, not interpreted as UTF8.
|
|
|
|
Stringp String::createLatin1(AvmCore* core, const char* buffer, int32_t len, Width desiredWidth, bool staticBuf)
|
|
{
|
|
if (buffer == NULL)
|
|
{
|
|
len = 0;
|
|
buffer = &k_zero.c8;
|
|
staticBuf = true;
|
|
}
|
|
if (len < 0)
|
|
len = Length(buffer);
|
|
|
|
if (desiredWidth == kAuto)
|
|
desiredWidth = k8;
|
|
|
|
if (desiredWidth == k8 && core->kEmptyString != NULL)
|
|
{
|
|
// core has been initialized, check for cached characters
|
|
if (len == 0)
|
|
return core->kEmptyString;
|
|
|
|
if (len == 1 && *((uint8_t*) buffer) < 128)
|
|
return core->cachedChars[*((uint8_t*) buffer)];
|
|
}
|
|
|
|
const bool is7bit = false; // actually, might be, we just haven't checked yet.
|
|
|
|
Stringp s = NULL;
|
|
GC* gc = core->GetGC();
|
|
if (staticBuf && desiredWidth == k8)
|
|
{
|
|
s = createStatic(gc, buffer, len, k8, is7bit);
|
|
}
|
|
else
|
|
{
|
|
s = createDynamic(gc, NULL, len, desiredWidth, is7bit);
|
|
_copyBuffers(buffer, s->m_buffer.p8, len, k8, desiredWidth);
|
|
VERIFY_7BIT(s);
|
|
}
|
|
return s;
|
|
}
|
|
|
|
Stringp String::getFixedWidthString(Width w) const
|
|
{
|
|
if (w == getWidth())
|
|
return (Stringp) this;
|
|
|
|
if (w == kAuto)
|
|
return NULL;
|
|
|
|
const bool is7bit = false;
|
|
Stringp newStr = createDynamic(_gc(this), NULL, m_length, w, is7bit);
|
|
|
|
Pointers ptrs(this);
|
|
Pointers new_ptrs(newStr);
|
|
_copyBuffers(ptrs.pv, new_ptrs.pv, m_length, getWidth(), w);
|
|
|
|
VERIFY_7BIT(newStr);
|
|
return newStr;
|
|
}
|
|
|
|
/////////////////////////////// Destructors & tracers ////////////////////////////////
|
|
|
|
String::~String()
|
|
{
|
|
switch (getType())
|
|
{
|
|
case kDynamic: {
|
|
// Never necessary to WB() when we store NULL over a non-RC pointer
|
|
void* pv = m_buffer.pv;
|
|
m_buffer.pv = NULL; // Avoid dangling the pointer
|
|
_gc(this)->FreeNotNull(pv);
|
|
break;
|
|
}
|
|
case kDependent:
|
|
// WBRC() is however necessary when we store NULL over an RC pointer
|
|
WBRC_NULL(&m_extra.master);
|
|
break;
|
|
default: ; // kStatic
|
|
}
|
|
m_extra.master = NULL; // might have already been cleared above, but that's ok
|
|
m_buffer.p8 = NULL; // might have already been cleared above, but that's ok
|
|
m_length = 0;
|
|
m_bitsAndFlags = 0;
|
|
}
|
|
|
|
/*virtual*/
|
|
bool String::gcTrace(GC* gc, size_t cursor)
|
|
{
|
|
(void)cursor;
|
|
switch (getType())
|
|
{
|
|
case kDynamic:
|
|
gc->TraceLocation(&m_buffer.pv);
|
|
break;
|
|
case kDependent:
|
|
gc->TraceLocation(&m_extra.master);
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/////////////////////////////// Conversions ////////////////////////////////
|
|
|
|
void String::makeDynamic(const uint8_t* dataStart, uint32_t dataSize)
|
|
{
|
|
AvmAssert(dataStart != NULL);
|
|
AvmAssert(dataSize > 0);
|
|
switch(getType())
|
|
{
|
|
case kStatic:
|
|
// do not convert if range is given and data falls within
|
|
if ((uint32_t) (m_buffer.p8 - dataStart) >= dataSize)
|
|
break;
|
|
// else fall thru
|
|
case kDependent:
|
|
convertToDynamic();
|
|
break;
|
|
default:;
|
|
}
|
|
}
|
|
|
|
void String::fixDependentString()
|
|
{
|
|
if (!isDependent())
|
|
return;
|
|
|
|
// If the length of this instance is > the master length, this
|
|
// string is the result of an auto-concat; we keep the master in
|
|
// in that case - there is little to no memory gain to be expected.
|
|
// Also, forget about conversion if the memory to be gained is minimal.
|
|
if (m_length >= (m_extra.master->m_length - (TSTR_DEPENDENT_STRING_NUISANCE_SAVINGS >> getWidth())))
|
|
return;
|
|
|
|
// Do not convert to a static string here, because a static string
|
|
// may be converted to a dynamic string, which would leave leave an interior
|
|
// pointer to the static content in the string instance.
|
|
convertToDynamic();
|
|
}
|
|
|
|
void String::convertToDynamic()
|
|
{
|
|
AvmAssert(getType() != kDynamic);
|
|
// Convert this string to be a dynamic string
|
|
int32_t bytes = m_length << getWidth(); // No overflow by definition
|
|
GC* gc = _gc(this);
|
|
MMGC_MEM_TYPE( this );
|
|
void* buf = gc->Alloc(bytes, 0);
|
|
VMPI_memcpy(buf, Pointers(this).pv, bytes);
|
|
WB(gc, this, &this->m_buffer.pv, buf);
|
|
if (isDependent())
|
|
WBRC_NULL(&m_extra.master);
|
|
setType(kDynamic);
|
|
}
|
|
|
|
/////////////////////////////// Comparison /////////////////////////////////
|
|
|
|
int32_t String::Compare(String& other, int32_t other_start, int32_t other_length) const
|
|
{
|
|
if (this == &other)
|
|
return 0;
|
|
|
|
if (other_start >= other.m_length)
|
|
return -1;
|
|
|
|
if (other_length < 1 || other_length > other.m_length)
|
|
other_length = other.m_length;
|
|
if (other_start < 0)
|
|
other_start = 0;
|
|
|
|
int32_t result = 0;
|
|
|
|
int32_t len = (m_length < other_length) ? m_length : other_length; // choose smaller of two
|
|
if (len > 0)
|
|
{
|
|
Pointers ptrs(this);
|
|
Pointers other_ptrs(&other);
|
|
Width const w1 = this->getWidth();
|
|
Width const w2 = other.getWidth();
|
|
switch ((w1 << 1) + w2)
|
|
{
|
|
case (k8 << 1) + k8:
|
|
result = compareImpl(ptrs.p8, other_ptrs.p8 + other_start, len);
|
|
break;
|
|
|
|
case (k8 << 1) + k16:
|
|
result = compareImpl(ptrs.p8, other_ptrs.p16 + other_start, len);
|
|
break;
|
|
|
|
case (k16 << 1) + k8:
|
|
result = compareImpl(ptrs.p16, other_ptrs.p8 + other_start, len);
|
|
break;
|
|
|
|
case (k16 << 1) + k16:
|
|
result = compareImpl(ptrs.p16, other_ptrs.p16 + other_start, len);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (result == 0)
|
|
{
|
|
// catch substring compares
|
|
result = (other_length - m_length);
|
|
if (result < 0)
|
|
result = -1;
|
|
else if (result > 0)
|
|
result = 1;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
bool String::equalsLatin1(const char* p, int32_t len) const
|
|
{
|
|
if (len < 0)
|
|
len = Length(p);
|
|
|
|
if (len != length())
|
|
return false;
|
|
|
|
Pointers ptrs(this);
|
|
if (getWidth() == k8)
|
|
{
|
|
return equalsImpl(ptrs.p8, (const uint8_t*)p, len);
|
|
}
|
|
else
|
|
{
|
|
return equalsImpl(ptrs.p16, (const uint8_t*)p, len);
|
|
}
|
|
}
|
|
|
|
bool String::equalsUTF16(const wchar* p, int32_t len) const
|
|
{
|
|
if (len != length())
|
|
return false;
|
|
|
|
Pointers ptrs(this);
|
|
if (getWidth() == k8)
|
|
{
|
|
return equalsImpl(ptrs.p8, p, len);
|
|
}
|
|
else
|
|
{
|
|
return equalsImpl(ptrs.p16, p, len);
|
|
}
|
|
}
|
|
|
|
bool String::equals(Stringp that) const
|
|
{
|
|
if (this == that)
|
|
return true;
|
|
|
|
int32_t const len1 = this->length();
|
|
int32_t const len2 = that->length();
|
|
if (len1 != len2)
|
|
return false;
|
|
|
|
Width const w1 = this->getWidth();
|
|
Width const w2 = that->getWidth();
|
|
|
|
Pointers thisbuf(this);
|
|
Pointers thatbuf(that);
|
|
|
|
switch ((w1 << 1) + w2)
|
|
{
|
|
case (k8 << 1) + k8:
|
|
return equalsImpl(thisbuf.p8, thatbuf.p8, len1);
|
|
|
|
case (k8 << 1) + k16:
|
|
return equalsImpl(thisbuf.p8, thatbuf.p16, len1);
|
|
|
|
case (k16 << 1) + k8:
|
|
return equalsImpl(thisbuf.p16, thatbuf.p8, len1);
|
|
|
|
case (k16 << 1) + k16:
|
|
return equalsImpl(thisbuf.p16, thatbuf.p16, len1);
|
|
}
|
|
AvmAssert(0);
|
|
return true;
|
|
}
|
|
|
|
#ifdef VMCFG_NANOJIT
|
|
/*static*/ int32_t String::equalsWithNullChecks(Stringp s1, Stringp s2)
|
|
{
|
|
if (s1 == s2)
|
|
return true;
|
|
|
|
if (!s1 || !s2)
|
|
return false;
|
|
|
|
int32_t const len1 = s1->length();
|
|
int32_t const len2 = s2->length();
|
|
if (len1 != len2)
|
|
return false;
|
|
|
|
Width const w1 = s1->getWidth();
|
|
Width const w2 = s2->getWidth();
|
|
|
|
Pointers thisbuf(s1);
|
|
Pointers thatbuf(s2);
|
|
|
|
switch ((w1 << 1) + w2)
|
|
{
|
|
case (k8 << 1) + k8:
|
|
return equalsImpl(thisbuf.p8, thatbuf.p8, len1);
|
|
|
|
case (k8 << 1) + k16:
|
|
return equalsImpl(thisbuf.p8, thatbuf.p16, len1);
|
|
|
|
case (k16 << 1) + k8:
|
|
return equalsImpl(thisbuf.p16, thatbuf.p8, len1);
|
|
|
|
case (k16 << 1) + k16:
|
|
return equalsImpl(thisbuf.p16, thatbuf.p16, len1);
|
|
}
|
|
AvmAssert(0);
|
|
return true;
|
|
}
|
|
#endif // VMCFG_NANOJIT
|
|
|
|
/////////////////////////////// Hash Codes /////////////////////////////////
|
|
|
|
// The hashing algorithm uses the full character width
|
|
|
|
int32_t String::hashCodeLatin1(const char* buf, int32_t len)
|
|
{
|
|
return hashCodeImpl((const utf8_t*)buf, len);
|
|
}
|
|
|
|
int32_t String::hashCodeUTF16(const wchar* buf, int32_t len)
|
|
{
|
|
return hashCodeImpl(buf, len);
|
|
}
|
|
|
|
int32_t String::hashCodeUInt(uint32_t value)
|
|
{
|
|
// Below is largely partial-evaluated composition of
|
|
// MathUtils::convertIntegerToStringBuffer and
|
|
// String::hashCodeLatin1
|
|
|
|
int32_t radix = 10;
|
|
|
|
int32_t hashCode = 0;
|
|
|
|
int32_t len = stringLengthUInt(value);
|
|
|
|
if (value == 0)
|
|
{
|
|
hashCode = hashCodeAddChar(hashCode, '0');
|
|
}
|
|
else
|
|
{
|
|
uintptr_t uVal = (uintptr_t)value;
|
|
uintptr_t factor = 1;
|
|
uintptr_t cursor = len;
|
|
while (--cursor)
|
|
factor *= radix;
|
|
cursor = len;
|
|
|
|
while (cursor > 0)
|
|
{
|
|
uintptr_t j = uVal;
|
|
j /= factor;
|
|
uVal %= factor;
|
|
factor /= radix;
|
|
AvmAssert( j < 10 );
|
|
hashCode = hashCodeAddChar(hashCode, (char)(j+'0'));
|
|
cursor--;
|
|
}
|
|
}
|
|
|
|
return hashCode;
|
|
}
|
|
|
|
int32_t String::hashCode() const
|
|
{
|
|
if (m_length != 0)
|
|
{
|
|
Pointers ptrs(this);
|
|
if (getWidth() == k8)
|
|
{
|
|
return hashCodeImpl(ptrs.p8, m_length);
|
|
}
|
|
else
|
|
{
|
|
return hashCodeImpl(ptrs.p16, m_length);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//////////////////////////////// Accessors /////////////////////////////////
|
|
|
|
wchar FASTCALL String::charAt(int32_t index) const
|
|
{
|
|
AvmAssert(index >= 0 && index < m_length);
|
|
|
|
Pointers ptrs(this);
|
|
return (getWidth() == k8) ? ptrs.p8[index] : ptrs.p16[index];
|
|
}
|
|
|
|
int32_t String::indexOf(Stringp substr, int32_t start) const
|
|
{
|
|
if (substr == NULL)
|
|
return -1;
|
|
|
|
// bug 78346: argv[1] might be less than zero.
|
|
// We clamp it to zero for two reasons:
|
|
// 1. A movie created prior to this fix with a small negative value probably worked,
|
|
// so let's fix it without breaking them.
|
|
// 2. I am told this is what java does.
|
|
if (start < 0)
|
|
start = 0;
|
|
|
|
int32_t len = this->length();
|
|
|
|
if (start > len)
|
|
start = len;
|
|
|
|
int32_t sublen = substr->length();
|
|
|
|
if (sublen == 0)
|
|
return start;
|
|
|
|
// right is the last character in selfString subStr could be found at
|
|
// (and further, and there isn't enough of selfString remaining for a match to be possible)
|
|
const int32_t right = len - sublen;
|
|
if (right < 0)
|
|
return -1;
|
|
|
|
Width const w1 = getWidth();
|
|
Width const w2 = substr->getWidth();
|
|
|
|
Pointers selfBuf(this);
|
|
Pointers subBuf(substr);
|
|
|
|
// For maximum performance, use different cases for k8/k16 combinations
|
|
if (sublen == 1)
|
|
{
|
|
switch ((w1 << 1) + w2)
|
|
{
|
|
case (k8 << 1) + k8:
|
|
return indexOfCharCodeImpl(selfBuf.p8, start, right, subBuf.p8[0]);
|
|
|
|
case (k8 << 1) + k16:
|
|
return indexOfCharCodeImpl(selfBuf.p8, start, right, subBuf.p16[0]);
|
|
|
|
case (k16 << 1) + k8:
|
|
return indexOfCharCodeImpl(selfBuf.p16, start, right, subBuf.p8[0]);
|
|
|
|
case (k16 << 1) + k16:
|
|
return indexOfCharCodeImpl(selfBuf.p16, start, right, subBuf.p16[0]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch ((w1 << 1) + w2)
|
|
{
|
|
case (k8 << 1) + k8:
|
|
return indexOfImpl(selfBuf.p8, start, right, subBuf.p8, sublen);
|
|
|
|
case (k8 << 1) + k16:
|
|
return indexOfImpl(selfBuf.p8, start, right, subBuf.p16, sublen);
|
|
|
|
case (k16 << 1) + k8:
|
|
return indexOfImpl(selfBuf.p16, start, right, subBuf.p8, sublen);
|
|
|
|
case (k16 << 1) + k16:
|
|
return indexOfImpl(selfBuf.p16, start, right, subBuf.p16, sublen);
|
|
}
|
|
}
|
|
AvmAssert(0);
|
|
return -1;
|
|
}
|
|
|
|
int32_t String::lastIndexOf(Stringp substr, int32_t start) const
|
|
{
|
|
if (substr == NULL)
|
|
return -1;
|
|
|
|
// lastIndexOf("anything", negative-number) can't match anything, ever:
|
|
// match FP10's behavior and return -1 immediately.
|
|
if (start < 0)
|
|
return -1;
|
|
|
|
int32_t len = this->length();
|
|
|
|
if (start > len)
|
|
start = len;
|
|
|
|
int32_t sublen = substr->length();
|
|
|
|
if (sublen == 0)
|
|
return start;
|
|
|
|
// Any match starting after right must necessarily fail, as there will be
|
|
// insufficient characters remaining to match.
|
|
const int32_t right = len - sublen;
|
|
|
|
// The substring is longer than selfString, and therefore no match is possible.
|
|
// We must avoid setting start to a negative value below.
|
|
if (right < 0)
|
|
return -1;
|
|
|
|
// bug 78346: argv[1] might be greater than right
|
|
// (similar reasons to above apply).
|
|
if (start > right)
|
|
start = right;
|
|
|
|
Width w1 = getWidth();
|
|
Width w2 = substr->getWidth();
|
|
|
|
Pointers selfBuf(this);
|
|
Pointers subBuf(substr);
|
|
|
|
// For maximum performance, use different cases for k8/k16 combinations
|
|
switch ((w1 << 1) + w2)
|
|
{
|
|
case (k8 << 1) + k8:
|
|
return lastIndexOfImpl(selfBuf.p8, start, subBuf.p8, sublen);
|
|
|
|
case (k8 << 1) + k16:
|
|
return lastIndexOfImpl(selfBuf.p8, start, subBuf.p16, sublen);
|
|
|
|
case (k16 << 1) + k8:
|
|
return lastIndexOfImpl(selfBuf.p16, start, subBuf.p8, sublen);
|
|
|
|
case (k16 << 1) + k16:
|
|
return lastIndexOfImpl(selfBuf.p16, start, subBuf.p16, sublen);
|
|
}
|
|
AvmAssert(0);
|
|
return -1;
|
|
}
|
|
|
|
int32_t String::indexOfLatin1(const char* p, int32_t sublen, int32_t start, int32_t end) const
|
|
{
|
|
if (start < 0)
|
|
start = 0;
|
|
if (end < 0)
|
|
end = 0;
|
|
if (end > m_length)
|
|
end = m_length;
|
|
|
|
if (p == NULL || end <= start)
|
|
return -1;
|
|
|
|
if (sublen < 0)
|
|
sublen = Length(p);
|
|
|
|
if (sublen == 0)
|
|
return start;
|
|
|
|
int32_t right = end - sublen;
|
|
if (right < 0)
|
|
return -1;
|
|
|
|
Width w = getWidth();
|
|
|
|
Pointers selfBuf(this);
|
|
if (w == k8)
|
|
{
|
|
return indexOfImpl(selfBuf.p8, start, right, (const uint8_t*)p, sublen);
|
|
}
|
|
else
|
|
{
|
|
return indexOfImpl(selfBuf.p16, start, right, (const uint8_t*)p, sublen);
|
|
}
|
|
}
|
|
|
|
int32_t String::indexOfCharCode(wchar c, int32_t start, int32_t end) const
|
|
{
|
|
if (start < 0)
|
|
start = 0;
|
|
if (end < 0)
|
|
end = 0;
|
|
if (end > m_length)
|
|
end = m_length;
|
|
|
|
if (end <= start)
|
|
return -1;
|
|
|
|
int32_t right = end - 1;
|
|
if (right < 0)
|
|
return -1;
|
|
|
|
Pointers ptrs(this);
|
|
if (getWidth() == String::k8)
|
|
{
|
|
return indexOfCharCodeImpl(ptrs.p8, start, right, c);
|
|
}
|
|
else
|
|
{
|
|
return indexOfCharCodeImpl(ptrs.p16, start, right, c);
|
|
}
|
|
}
|
|
|
|
bool String::matchesLatin1(const char* p, int32_t len, int32_t pos)
|
|
{
|
|
if (p == NULL || pos >= m_length)
|
|
return false;
|
|
|
|
if (pos < 0)
|
|
pos = 0;
|
|
if (len < 0)
|
|
len = Length(p);
|
|
|
|
Pointers ptrs(this);
|
|
if (getWidth() == k8)
|
|
{
|
|
return equalsImpl(ptrs.p8 + pos, (const uint8_t*)p, len);
|
|
}
|
|
else
|
|
{
|
|
return equalsImpl(ptrs.p16 + pos, (const uint8_t*)p, len);
|
|
}
|
|
}
|
|
|
|
bool String::matchesLatin1_caseless(const char* p, int32_t len, int32_t pos)
|
|
{
|
|
if (p == NULL || pos >= m_length)
|
|
return false;
|
|
|
|
if (pos < 0)
|
|
pos = 0;
|
|
if (len < 0)
|
|
len = Length(p);
|
|
|
|
StringIndexer self(this);
|
|
while (len--)
|
|
{
|
|
wchar const ch1 = wCharToUpper(self[pos++]);
|
|
wchar const ch2 = wCharToUpper(uint8_t(*p++));
|
|
if (ch1 != ch2)
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
///////////////////////////// Concatenation ////////////////////////////////
|
|
|
|
/*static*/ Stringp String::concatStrings(Stringp leftStr, Stringp rightStr)
|
|
{
|
|
if (leftStr == NULL || leftStr->m_length == 0)
|
|
return rightStr;
|
|
|
|
return leftStr->_append(rightStr, Pointers(rightStr), rightStr->length(), rightStr->getWidth());
|
|
}
|
|
|
|
Stringp String::append(Stringp rightStr)
|
|
{
|
|
if (rightStr == NULL || rightStr->m_length == 0)
|
|
return this;
|
|
|
|
return _append(rightStr, Pointers(rightStr), rightStr->length(), rightStr->getWidth());
|
|
}
|
|
|
|
// NB: if rightStrPtr is nonnull, it is assumed to be the source of rightStr.
|
|
// In this case, rightStr is assumed to be invalidate by any possible GC activity,
|
|
// and will be re-created from rightStrPtr.
|
|
Stringp String::_append(Stringp rightStrPtr, const Pointers& rightStr, int32_t numChars, Width charWidth)
|
|
{
|
|
if (numChars <= 0)
|
|
return this;
|
|
|
|
AvmAssert(charWidth != kAuto);
|
|
|
|
MMgc::GC* gc = _gc(this);
|
|
// fromCharCode() optimization: If this string is empty, and the buffer is a single
|
|
// ASCII character, return the cached character
|
|
if (m_length == 0 && numChars == 1)
|
|
{
|
|
// Sun studio generated wrong code for the following Conditional operator.
|
|
// Add type conversion to wchar as a workaround.
|
|
wchar ch = (charWidth == k8) ? (wchar)rightStr.p8[0] : (wchar)rightStr.p16[0];
|
|
if (ch < 128)
|
|
return gc->core()->cachedChars[ch];
|
|
}
|
|
|
|
Width thisWidth = getWidth();
|
|
Width newWidth = (thisWidth < charWidth) ? charWidth : thisWidth;
|
|
|
|
int32_t newLen = int32AddChecked(m_length, numChars);
|
|
|
|
Stringp master = (isDependent()) ? m_extra.master : this;
|
|
// check for characters left in leftStr's buffer, or if leftStr has spent its padding already
|
|
// string types other than kDynamic have charsLeft == 0
|
|
int32_t charsLeft = 0;
|
|
int32_t charsUsed = 0;
|
|
if (thisWidth >= charWidth)
|
|
{
|
|
// in-place append only if rightStr's width fits into leftStr
|
|
charsLeft = master->getCharsLeft();
|
|
if (!master->isStatic())
|
|
// charsUsed is the number of chars already spent behind m_length
|
|
// Usage of m_buffer is OK - master can never be dependent
|
|
charsUsed = int32_t((GC::Size(master->m_buffer.pv) >> thisWidth) - master->m_length - charsLeft);
|
|
}
|
|
int32_t start = 0; // string start for dependent strings
|
|
|
|
// it is possible to append in-place if
|
|
// 1) this is a kDynamic string and charsUsed == 0
|
|
// 2) this is a kDependent string and the end matches the master's real end
|
|
switch (getType())
|
|
{
|
|
case kDynamic:
|
|
if (charsUsed != 0)
|
|
// someone else has already appended in-place
|
|
charsLeft = 0;
|
|
break;
|
|
case kDependent:
|
|
start = (int32_t) m_buffer.offset_bytes >> thisWidth;
|
|
if ((start + m_length) != master->m_length + charsUsed)
|
|
charsLeft = 0;
|
|
break;
|
|
default:; // kStatic
|
|
}
|
|
|
|
// the big check: are there enough chars left?
|
|
if (numChars <= charsLeft)
|
|
{
|
|
// the right-hand string fits into the buffer end
|
|
_copyBuffers(rightStr.pv,
|
|
Pointers(this).p8 + (m_length << thisWidth), // m_length << thiswidth is safe by definition
|
|
numChars, charWidth, newWidth);
|
|
|
|
charsUsed += numChars;
|
|
charsLeft -= numChars;
|
|
master->setCharsLeft(charsLeft);
|
|
#ifdef _DEBUG
|
|
// Terminate string with 0 for better debugging display
|
|
if (charsLeft && !master->isStatic())
|
|
{
|
|
int32_t end = master->m_length + charsUsed;
|
|
if (newWidth == k8)
|
|
master->m_buffer.p8[end] = 0;
|
|
else
|
|
master->m_buffer.p16[end] = 0;
|
|
}
|
|
#endif
|
|
Stringp s = createDependent(gc, master, start, newLen);
|
|
// createDependent propagates the 7-bit flag, which is a good idea for substrings.
|
|
// however, if we are adding data, it may no longer qualify. rather than checking
|
|
// the appended data, just clear the flag (it will be lazily recalculated as needed)
|
|
s->m_bitsAndFlags &= ~TSTR_7BIT_FLAG;
|
|
return s;
|
|
}
|
|
|
|
// fall thru - string does not fit
|
|
// create a new kDynamic string containing the concatenated string
|
|
// See the definition of TSTR_MAX_CHARSLEFT above for an explanation
|
|
// of this algorithm
|
|
int32_t newSize = (newLen < TSTR_MIN_DYNAMIC_ALLOCATION) ? TSTR_MIN_DYNAMIC_ALLOCATION : int32ShlChecked(newLen, 1);
|
|
int32_t extra = newSize - newLen;
|
|
if (extra > (int32_t) TSTR_MAX_CHARSLEFT)
|
|
extra = (int32_t) TSTR_MAX_CHARSLEFT;
|
|
|
|
const bool is7bit = false; // actually, might be, we just haven't checked yet.
|
|
Stringp newStr = createDynamic(gc, NULL, newLen, newWidth, is7bit, extra);
|
|
|
|
// note that createDynamic has invalidated any existing Pointers structs...
|
|
const void* srcLeft = Pointers(this).pv;
|
|
const void* srcRight = rightStrPtr ? Pointers(rightStrPtr).pv : rightStr.pv;
|
|
|
|
// copy leftStr
|
|
void* ptr = _copyBuffers(srcLeft,
|
|
newStr->m_buffer.pv,
|
|
m_length,
|
|
thisWidth, newWidth);
|
|
|
|
// append src
|
|
_copyBuffers(srcRight,
|
|
ptr,
|
|
numChars,
|
|
charWidth, newWidth);
|
|
|
|
#ifdef _DEBUG
|
|
// Terminate string with 0 for better debugging display
|
|
if (newStr->getCharsLeft())
|
|
{
|
|
if (newWidth == k8)
|
|
newStr->m_buffer.p8[newStr->m_length] = 0;
|
|
else
|
|
newStr->m_buffer.p16[newStr->m_length] = 0;
|
|
}
|
|
#endif
|
|
VERIFY_7BIT(newStr);
|
|
return newStr;
|
|
}
|
|
|
|
/////////////////////////////// substrings /////////////////////////////////
|
|
|
|
// Remember: string runs from start up to, but not including, the end!
|
|
Stringp String::substring(int32_t start, int32_t end)
|
|
{
|
|
if (start < 0)
|
|
start = 0;
|
|
else if (start > m_length)
|
|
start = m_length;
|
|
if (end < 0)
|
|
end = 0;
|
|
else if (end > m_length)
|
|
end = m_length;
|
|
|
|
// does the substring span this string?
|
|
if (start == 0 && end == m_length)
|
|
return this;
|
|
|
|
MMgc::GC* gc = _gc(this);
|
|
AvmCore* core = gc->core();
|
|
// for empty strings, return the standard Empty String instance
|
|
if (end <= start)
|
|
return core->kEmptyString;
|
|
|
|
// for single characters < 128, return the cached string
|
|
if (end == (start + 1))
|
|
{
|
|
wchar const ch = charAt(start);
|
|
if (ch < 128)
|
|
return core->cachedChars[ch];
|
|
}
|
|
|
|
// otherwise, create a dependent string
|
|
Stringp master = this;
|
|
if (isDependent())
|
|
{
|
|
// get the string offset
|
|
master = m_extra.master;
|
|
// TODO: possible 32-bit overflow for a very huge dependent string
|
|
int32_t offset = (int32_t) m_buffer.offset_bytes >> getWidth();
|
|
start += (int32_t) offset;
|
|
end += (int32_t) offset;
|
|
}
|
|
AvmAssert(!master->isDependent());
|
|
// you may be tempted to optimize for static strings, by creating
|
|
// a new static string pointing to the substring... do not do this.
|
|
// it will break static strings that point directly into ABC buffers.
|
|
return createDependent(gc, master, start, end - start);
|
|
}
|
|
|
|
Stringp String::clone(AvmCore* targetCore)
|
|
{
|
|
// FIXME can this work? ensure GC is not running for the duration of this call?
|
|
// FIXME ensure that client code interns the return value in targetCore appropriately.
|
|
int32_t len = length();
|
|
String::Pointers p(this);
|
|
// hopefully _core() is not used in here
|
|
if (getWidth() == String::k8) {
|
|
return createLatin1(targetCore, (const char*) p.p8, len, String::k8, false);
|
|
} else {
|
|
return createUTF16(targetCore, p.p16, len, String::k16, false, false);
|
|
}
|
|
}
|
|
|
|
Stringp String::substr(int32_t start, int32_t len)
|
|
{
|
|
start = (int32_t) NativeObjectHelpers::ClampIndexInt(start, m_length);
|
|
len = (int32_t) NativeObjectHelpers::ClampIndexInt(len, m_length);
|
|
int32_t end = (m_length-len<=start)? m_length:start+len; // no need to further clamp
|
|
return substring(start, end);
|
|
}
|
|
|
|
Stringp String::slice(int32_t start, int32_t end)
|
|
{
|
|
start = (int32_t) NativeObjectHelpers::ClampIndexInt(start, m_length);
|
|
end = (int32_t) NativeObjectHelpers::ClampIndexInt(end, m_length);
|
|
if (end < start)
|
|
end = start;
|
|
|
|
return substr(start, end-start);
|
|
}
|
|
|
|
////////////////////////////////// Parsing ////////////////////////////////////
|
|
|
|
// This routine is a very specific parser to generate a positive integer from a string.
|
|
// The following are supported:
|
|
// "0" - one single digit for zero - NOT "00" or any other form of zero
|
|
//[1-9]+[0-9]* up to 2^32-2 (4294967294)
|
|
// 2^32-1 (4294967295) is not supported (see ECMA quote below).
|
|
// The ECMA that we're supporting with this routine is...
|
|
// cn: the ES3 test for a valid array index is
|
|
// "A property name P (in the form of a string value) is an array index if and
|
|
// only if ToString(ToUint32(P)) is equal to P and ToUint32(P) is not equal to 2^32-1."
|
|
|
|
// Don't support 000000 as 0.
|
|
// We don't support 0x1234 as 1234 in hex since string(1234) doesn't equal '0x1234')
|
|
// No leading zeros are supported
|
|
|
|
bool String::parseIndex(uint32_t& result) const
|
|
{
|
|
// avoid parsing if this string is definitely not a candidate
|
|
// A string that is more than 10 digits (and does not start with 0)
|
|
// will always be greater than 2^32-1 (4294967295) or not a numeric string
|
|
if (m_bitsAndFlags & TSTR_NOUINT_FLAG)
|
|
return false;
|
|
|
|
if (m_bitsAndFlags & (TSTR_UINT28_FLAG | TSTR_UINT32_FLAG))
|
|
{
|
|
result = m_extra.index;
|
|
return true;
|
|
}
|
|
|
|
int64_t n = 0;
|
|
wchar wch;
|
|
Pointers ptrs(this);
|
|
Width w = getWidth();
|
|
if (m_length == 0 || m_length > 10)
|
|
goto bad;
|
|
|
|
// collect the value
|
|
for (int32_t i = 0; i < m_length; i++)
|
|
{
|
|
if (w == k8)
|
|
wch = wchar(*ptrs.p8++);
|
|
else
|
|
wch = *ptrs.p16++;
|
|
// bad character, or leading zero?
|
|
if (wch < '0' || wch > '9' || (i == 1 && n == 0))
|
|
goto bad;
|
|
n = (n * 10) + wch - '0';
|
|
}
|
|
// out of range?
|
|
if (n >= 0xFFFFFFFF)
|
|
goto bad;
|
|
if (n & ScriptObject::MAX_INTEGER_MASK)
|
|
m_bitsAndFlags |= TSTR_NOINT_FLAG;
|
|
if (!isDependent())
|
|
{
|
|
m_bitsAndFlags |= TSTR_UINT32_FLAG;
|
|
m_extra.index = uint32_t(n);
|
|
}
|
|
result = uint32_t(n);
|
|
return true;
|
|
bad:
|
|
m_bitsAndFlags |= TSTR_NOINT_FLAG | TSTR_NOUINT_FLAG;
|
|
return false;
|
|
}
|
|
|
|
Atom String::getIntAtom() const
|
|
{
|
|
// The call uses a simplified version of parseIndex with 32-bit arithmetic,
|
|
// since we can only fit 28 bits.
|
|
if (m_bitsAndFlags & TSTR_NOINT_FLAG)
|
|
return 0;
|
|
|
|
if (m_bitsAndFlags & TSTR_UINT28_FLAG)
|
|
return Atom((m_extra.index << 3) | AtomConstants::kIntptrType);
|
|
|
|
int32_t n = 0;
|
|
wchar wch;
|
|
Pointers ptrs(this);
|
|
Width w = getWidth();
|
|
if (m_length == 0 || m_length > 10)
|
|
goto bad;
|
|
|
|
// collect the value
|
|
for (int32_t i = 0; i < m_length; i++)
|
|
{
|
|
if (w == k8)
|
|
wch = wchar(*ptrs.p8++);
|
|
else
|
|
wch = *ptrs.p16++;
|
|
// bad character, or leading zero?
|
|
if (wch < '0' || wch > '9' || (i == 1 && n == 0))
|
|
goto bad;
|
|
n = (n * 10) + wch - '0';
|
|
if (n & ScriptObject::MAX_INTEGER_MASK)
|
|
goto bad;
|
|
}
|
|
if (!isDependent())
|
|
{
|
|
m_bitsAndFlags |= TSTR_UINT28_FLAG;
|
|
m_extra.index = n;
|
|
}
|
|
return Atom((n << 3) | AtomConstants::kIntptrType);
|
|
bad:
|
|
m_bitsAndFlags |= TSTR_NOINT_FLAG;
|
|
return 0;
|
|
}
|
|
|
|
/////////////////////////////// Case conversion /////////////////////////////////
|
|
|
|
|
|
static const wchar lowerCaseBase[] =
|
|
{
|
|
/*0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006A,
|
|
0x006B, 0x006C, 0x006D, 0x006E, 0x006F, 0x0070, 0x0071, 0x0072, 0x0073, 0x0074,
|
|
0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007A,*/ 0x00B5, /*0x00E0, 0x00E1, 0x00E2,
|
|
0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7, 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC,
|
|
0x00ED, 0x00EE, 0x00EF, 0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6,
|
|
0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE,*/ 0x00FF, /*0x0101, 0x0103,
|
|
0x0105, 0x0107, 0x0109, 0x010B, 0x010D, 0x010F, 0x0111, 0x0113, 0x0115, 0x0117,
|
|
0x0119, 0x011B, 0x011D, 0x011F, 0x0121, 0x0123, 0x0125, 0x0127, 0x0129, 0x012B,
|
|
0x012D, 0x012F,*/ 0x0131, 0x0133, 0x0135, 0x0137, /*0x013A, 0x013C, 0x013E, 0x0140,
|
|
0x0142, 0x0144, 0x0146, 0x0148,*/ /*0x014B, 0x014D, 0x014F, 0x0151, 0x0153, 0x0155,
|
|
0x0157, 0x0159, 0x015B, 0x015D, 0x015F, 0x0161, 0x0163, 0x0165, 0x0167, 0x0169,
|
|
0x016B, 0x016D, 0x016F, 0x0171, 0x0173, 0x0175, 0x0177,*/ 0x017A, 0x017C, 0x017E,
|
|
0x017F, 0x0183, 0x0185, 0x0188, 0x018C, 0x0192, 0x0195, 0x0199, 0x01A1, 0x01A3,
|
|
0x01A5, 0x01A8, 0x01AD, 0x01B0, 0x01B4, 0x01B6, 0x01B9, 0x01BD, 0x01BF, 0x01C5,
|
|
0x01C6, 0x01C8, 0x01C9, 0x01CB, 0x01CC, 0x01CE, 0x01D0, 0x01D2, 0x01D4, 0x01D6,
|
|
0x01D8, 0x01DA, 0x01DC, 0x01DD, 0x01DF, 0x01E1, 0x01E3, 0x01E5, 0x01E7, 0x01E9,
|
|
0x01EB, 0x01ED, 0x01EF, 0x01F2, 0x01F3, 0x01F5, 0x01F9, 0x01FB, 0x01FD, 0x01FF,
|
|
/*0x0201, 0x0203, 0x0205, 0x0207, 0x0209, 0x020B, 0x020D, 0x020F, 0x0211, 0x0213,
|
|
0x0215, 0x0217, 0x0219, 0x021B, 0x021D, 0x021F, 0x0223, 0x0225, 0x0227, 0x0229,
|
|
0x022B, 0x022D, 0x022F, 0x0231, 0x0233,*/ 0x0253, 0x0254, 0x0256, 0x0257, 0x0259,
|
|
0x025B, 0x0260, 0x0263, 0x0268, 0x0269, 0x026F, 0x0272, 0x0275, 0x0280, 0x0283,
|
|
0x0288, 0x028A, 0x028B, 0x0292, 0x0345, 0x03AC, 0x03AD, 0x03AE, 0x03AF, /*0x03B1,
|
|
0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7, 0x03B8, 0x03B9, 0x03BA, 0x03BB,
|
|
0x03BC, 0x03BD, 0x03BE, 0x03BF, 0x03C0, 0x03C1, 0x03C2, 0x03C3, 0x03C4, 0x03C5,
|
|
0x03C6, 0x03C7, 0x03C8, 0x03C9, 0x03CA, 0x03CB,*/ 0x03CC, 0x03CD, 0x03CE, 0x03D0,
|
|
0x03D1, 0x03D5, 0x03D6, /*0x03DB, 0x03DD, 0x03DF, 0x03E1, 0x03E3, 0x03E5, 0x03E7,
|
|
0x03E9, 0x03EB, 0x03ED, 0x03EF,*/ 0x03F0, 0x03F1, 0x03F2, 0x03F5, /*0x0430, 0x0431,
|
|
0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0439, 0x043A, 0x043B,
|
|
0x043C, 0x043D, 0x043E, 0x043F, 0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445,
|
|
0x0446, 0x0447, 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,*/
|
|
/*0x0450, 0x0451, 0x0452, 0x0453, 0x0454, 0x0455, 0x0456, 0x0457, 0x0458, 0x0459,
|
|
0x045A, 0x045B, 0x045C, 0x045D, 0x045E, 0x045F,*/ /*0x0461, 0x0463, 0x0465, 0x0467,
|
|
0x0469, 0x046B, 0x046D, 0x046F, 0x0471, 0x0473, 0x0475, 0x0477, 0x0479, 0x047B,
|
|
0x047D, 0x047F, 0x0481, 0x048D, 0x048F, 0x0491, 0x0493, 0x0495, 0x0497, 0x0499,
|
|
0x049B, 0x049D, 0x049F, 0x04A1, 0x04A3, 0x04A5, 0x04A7, 0x04A9, 0x04AB, 0x04AD,
|
|
0x04AF, 0x04B1, 0x04B3, 0x04B5, 0x04B7, 0x04B9, 0x04BB, 0x04BD, 0x04BF,*/ 0x04C2,
|
|
0x04C4, 0x04C8, 0x04CC, /*0x04D1, 0x04D3, 0x04D5, 0x04D7, 0x04D9, 0x04DB, 0x04DD,
|
|
0x04DF, 0x04E1, 0x04E3, 0x04E5, 0x04E7, 0x04E9, 0x04EB, 0x04ED, 0x04EF, 0x04F1,
|
|
0x04F3, 0x04F5, 0x04F9, 0x0561, 0x0562, 0x0563, 0x0564, 0x0565, 0x0566, 0x0567,
|
|
0x0568, 0x0569, 0x056A, 0x056B, 0x056C, 0x056D, 0x056E, 0x056F, 0x0570, 0x0571,
|
|
0x0572, 0x0573, 0x0574, 0x0575, 0x0576, 0x0577, 0x0578, 0x0579, 0x057A, 0x057B,
|
|
0x057C, 0x057D, 0x057E, 0x057F, 0x0580, 0x0581, 0x0582, 0x0583, 0x0584, 0x0585,
|
|
0x0586, 0x1E01, 0x1E03, 0x1E05, 0x1E07, 0x1E09, 0x1E0B, 0x1E0D, 0x1E0F, 0x1E11,
|
|
0x1E13, 0x1E15, 0x1E17, 0x1E19, 0x1E1B, 0x1E1D, 0x1E1F, 0x1E21, 0x1E23, 0x1E25,
|
|
0x1E27, 0x1E29, 0x1E2B, 0x1E2D, 0x1E2F, 0x1E31, 0x1E33, 0x1E35, 0x1E37, 0x1E39,
|
|
0x1E3B, 0x1E3D, 0x1E3F, 0x1E41, 0x1E43, 0x1E45, 0x1E47, 0x1E49, 0x1E4B, 0x1E4D,
|
|
0x1E4F, 0x1E51, 0x1E53, 0x1E55, 0x1E57, 0x1E59, 0x1E5B, 0x1E5D, 0x1E5F, 0x1E61,
|
|
0x1E63, 0x1E65, 0x1E67, 0x1E69, 0x1E6B, 0x1E6D, 0x1E6F, 0x1E71, 0x1E73, 0x1E75,
|
|
0x1E77, 0x1E79, 0x1E7B, 0x1E7D, 0x1E7F, 0x1E81, 0x1E83, 0x1E85, 0x1E87, 0x1E89,
|
|
0x1E8B, 0x1E8D, 0x1E8F, 0x1E91, 0x1E93, 0x1E95,*/ 0x1E9B, /*0x1EA1, 0x1EA3, 0x1EA5,
|
|
0x1EA7, 0x1EA9, 0x1EAB, 0x1EAD, 0x1EAF, 0x1EB1, 0x1EB3, 0x1EB5, 0x1EB7, 0x1EB9,
|
|
0x1EBB, 0x1EBD, 0x1EBF, 0x1EC1, 0x1EC3, 0x1EC5, 0x1EC7, 0x1EC9, 0x1ECB, 0x1ECD,
|
|
0x1ECF, 0x1ED1, 0x1ED3, 0x1ED5, 0x1ED7, 0x1ED9, 0x1EDB, 0x1EDD, 0x1EDF, 0x1EE1,
|
|
0x1EE3, 0x1EE5, 0x1EE7, 0x1EE9, 0x1EEB, 0x1EED, 0x1EEF, 0x1EF1, 0x1EF3, 0x1EF5,
|
|
0x1EF7, 0x1EF9,*/ /*0x1F00, 0x1F01, 0x1F02, 0x1F03, 0x1F04, 0x1F05, 0x1F06, 0x1F07,*/
|
|
/*0x1F10, 0x1F11, 0x1F12, 0x1F13, 0x1F14, 0x1F15, 0x1F20, 0x1F21, 0x1F22, 0x1F23,
|
|
0x1F24, 0x1F25, 0x1F26, 0x1F27, 0x1F30, 0x1F31, 0x1F32, 0x1F33, 0x1F34, 0x1F35,
|
|
0x1F36, 0x1F37,*/ 0x1F40, 0x1F41, 0x1F42, 0x1F43, 0x1F44, 0x1F45, 0x1F51, 0x1F53,
|
|
0x1F55, 0x1F57, 0x1F60, 0x1F61, 0x1F62, 0x1F63, 0x1F64, 0x1F65, 0x1F66, 0x1F67,
|
|
0x1F70, 0x1F71, 0x1F72, 0x1F73, 0x1F74, 0x1F75, 0x1F76, 0x1F77, 0x1F78, 0x1F79,
|
|
0x1F7A, 0x1F7B, 0x1F7C, 0x1F7D, 0x1F80, 0x1F81, 0x1F82, 0x1F83, 0x1F84, 0x1F85,
|
|
0x1F86, 0x1F87, 0x1F90, 0x1F91, 0x1F92, 0x1F93, 0x1F94, 0x1F95, 0x1F96, 0x1F97,
|
|
0x1FA0, 0x1FA1, 0x1FA2, 0x1FA3, 0x1FA4, 0x1FA5, 0x1FA6, 0x1FA7, 0x1FB0, 0x1FB1,
|
|
0x1FB3, 0x1FBE, 0x1FC3, 0x1FD0, 0x1FD1, 0x1FE0, 0x1FE1, 0x1FE5, 0x1FF3 /*0x2170,
|
|
0x2171, 0x2172, 0x2173, 0x2174, 0x2175, 0x2176, 0x2177, 0x2178, 0x2179, 0x217A,
|
|
0x217B, 0x217C, 0x217D, 0x217E, 0x217F, 0x24D0, 0x24D1, 0x24D2, 0x24D3, 0x24D4,
|
|
0x24D5, 0x24D6, 0x24D7, 0x24D8, 0x24D9, 0x24DA, 0x24DB, 0x24DC, 0x24DD, 0x24DE,
|
|
0x24DF, 0x24E0, 0x24E1, 0x24E2, 0x24E3, 0x24E4, 0x24E5, 0x24E6, 0x24E7, 0x24E8,
|
|
0x24E9 0xFF41, 0xFF42, 0xFF43, 0xFF44, 0xFF45, 0xFF46, 0xFF47, 0xFF48, 0xFF49,
|
|
0xFF4A, 0xFF4B, 0xFF4C, 0xFF4D, 0xFF4E, 0xFF4F, 0xFF50, 0xFF51, 0xFF52, 0xFF53,
|
|
0xFF54, 0xFF55, 0xFF56, 0xFF57, 0xFF58, 0xFF59, 0xFF5A*/
|
|
};
|
|
|
|
static const wchar upperCaseConversion[] =
|
|
{
|
|
/*0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004A,
|
|
0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054,
|
|
0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005A,*/ 0x039C, /*0x00C0, 0x00C1, 0x00C2,
|
|
0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7, 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC,
|
|
0x00CD, 0x00CE, 0x00CF, 0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6,
|
|
0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE,*/ 0x0178, /*0x0100, 0x0102,
|
|
0x0104, 0x0106, 0x0108, 0x010A, 0x010C, 0x010E, 0x0110, 0x0112, 0x0114, 0x0116,
|
|
0x0118, 0x011A, 0x011C, 0x011E, 0x0120, 0x0122, 0x0124, 0x0126, 0x0128, 0x012A,
|
|
0x012C, 0x012E,*/ 0x0049, 0x0132, 0x0134, 0x0136, /*0x0139, 0x013B, 0x013D, 0x013F,
|
|
0x0141, 0x0143, 0x0145, 0x0147,*/ /*0x014A, 0x014C, 0x014E, 0x0150, 0x0152, 0x0154,
|
|
0x0156, 0x0158, 0x015A, 0x015C, 0x015E, 0x0160, 0x0162, 0x0164, 0x0166, 0x0168,
|
|
0x016A, 0x016C, 0x016E, 0x0170, 0x0172, 0x0174, 0x0176,*/ 0x0179, 0x017B, 0x017D,
|
|
0x0053, 0x0182, 0x0184, 0x0187, 0x018B, 0x0191, 0x01F6, 0x0198, 0x01A0, 0x01A2,
|
|
0x01A4, 0x01A7, 0x01AC, 0x01AF, 0x01B3, 0x01B5, 0x01B8, 0x01BC, 0x01F7, 0x01C4,
|
|
0x01C4, 0x01C7, 0x01C7, 0x01CA, 0x01CA, 0x01CD, 0x01CF, 0x01D1, 0x01D3, 0x01D5,
|
|
0x01D7, 0x01D9, 0x01DB, 0x018E, 0x01DE, 0x01E0, 0x01E2, 0x01E4, 0x01E6, 0x01E8,
|
|
0x01EA, 0x01EC, 0x01EE, 0x01F1, 0x01F1, 0x01F4, 0x01F8, 0x01FA, 0x01FC, 0x01FE,
|
|
/*0x0200, 0x0202, 0x0204, 0x0206, 0x0208, 0x020A, 0x020C, 0x020E, 0x0210, 0x0212,
|
|
0x0214, 0x0216, 0x0218, 0x021A, 0x021C, 0x021E, 0x0222, 0x0224, 0x0226, 0x0228,
|
|
0x022A, 0x022C, 0x022E, 0x0230, 0x0232,*/ 0x0181, 0x0186, 0x0189, 0x018A, 0x018F,
|
|
0x0190, 0x0193, 0x0194, 0x0197, 0x0196, 0x019C, 0x019D, 0x019F, 0x01A6, 0x01A9,
|
|
0x01AE, 0x01B1, 0x01B2, 0x01B7, 0x0399, 0x0386, 0x0388, 0x0389, 0x038A, /*0x0391,
|
|
0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x0398, 0x0399, 0x039A, 0x039B,
|
|
0x039C, 0x039D, 0x039E, 0x039F, 0x03A0, 0x03A1, 0x03A3, 0x03A3, 0x03A4, 0x03A5,
|
|
0x03A6, 0x03A7, 0x03A8, 0x03A9, 0x03AA, 0x03AB,*/ 0x038C, 0x038E, 0x038F, 0x0392,
|
|
0x0398, 0x03A6, 0x03A0, /*0x03DA, 0x03DC, 0x03DE, 0x03E0, 0x03E2, 0x03E4, 0x03E6,
|
|
0x03E8, 0x03EA, 0x03EC, 0x03EE,*/ 0x039A, 0x03A1, 0x03A3, 0x0395, /*0x0410, 0x0411,
|
|
0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, 0x0418, 0x0419, 0x041A, 0x041B,
|
|
0x041C, 0x041D, 0x041E, 0x041F, 0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425,
|
|
0x0426, 0x0427, 0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,*/
|
|
/*0x0400, 0x0401, 0x0402, 0x0403, 0x0404, 0x0405, 0x0406, 0x0407, 0x0408, 0x0409,
|
|
0x040A, 0x040B, 0x040C, 0x040D, 0x040E, 0x040F,*//*0x0460, 0x0462, 0x0464, 0x0466,
|
|
0x0468, 0x046A, 0x046C, 0x046E, 0x0470, 0x0472, 0x0474, 0x0476, 0x0478, 0x047A,
|
|
0x047C, 0x047E, 0x0480, 0x048C, 0x048E, 0x0490, 0x0492, 0x0494, 0x0496, 0x0498,
|
|
0x049A, 0x049C, 0x049E, 0x04A0, 0x04A2, 0x04A4, 0x04A6, 0x04A8, 0x04AA, 0x04AC,
|
|
0x04AE, 0x04B0, 0x04B2, 0x04B4, 0x04B6, 0x04B8, 0x04BA, 0x04BC, 0x04BE,*/ 0x04C1,
|
|
0x04C3, 0x04C7, 0x04CB, /*0x04D0, 0x04D2, 0x04D4, 0x04D6, 0x04D8, 0x04DA, 0x04DC,
|
|
0x04DE, 0x04E0, 0x04E2, 0x04E4, 0x04E6, 0x04E8, 0x04EA, 0x04EC, 0x04EE, 0x04F0,
|
|
0x04F2, 0x04F4, 0x04F8, 0x0531, 0x0532, 0x0533, 0x0534, 0x0535, 0x0536, 0x0537,
|
|
0x0538, 0x0539, 0x053A, 0x053B, 0x053C, 0x053D, 0x053E, 0x053F, 0x0540, 0x0541,
|
|
0x0542, 0x0543, 0x0544, 0x0545, 0x0546, 0x0547, 0x0548, 0x0549, 0x054A, 0x054B,
|
|
0x054C, 0x054D, 0x054E, 0x054F, 0x0550, 0x0551, 0x0552, 0x0553, 0x0554, 0x0555,
|
|
0x0556, 0x1E00, 0x1E02, 0x1E04, 0x1E06, 0x1E08, 0x1E0A, 0x1E0C, 0x1E0E, 0x1E10,
|
|
0x1E12, 0x1E14, 0x1E16, 0x1E18, 0x1E1A, 0x1E1C, 0x1E1E, 0x1E20, 0x1E22, 0x1E24,
|
|
0x1E26, 0x1E28, 0x1E2A, 0x1E2C, 0x1E2E, 0x1E30, 0x1E32, 0x1E34, 0x1E36, 0x1E38,
|
|
0x1E3A, 0x1E3C, 0x1E3E, 0x1E40, 0x1E42, 0x1E44, 0x1E46, 0x1E48, 0x1E4A, 0x1E4C,
|
|
0x1E4E, 0x1E50, 0x1E52, 0x1E54, 0x1E56, 0x1E58, 0x1E5A, 0x1E5C, 0x1E5E, 0x1E60,
|
|
0x1E62, 0x1E64, 0x1E66, 0x1E68, 0x1E6A, 0x1E6C, 0x1E6E, 0x1E70, 0x1E72, 0x1E74,
|
|
0x1E76, 0x1E78, 0x1E7A, 0x1E7C, 0x1E7E, 0x1E80, 0x1E82, 0x1E84, 0x1E86, 0x1E88,
|
|
0x1E8A, 0x1E8C, 0x1E8E, 0x1E90, 0x1E92, 0x1E94,*/ 0x1E60, /*0x1EA0, 0x1EA2, 0x1EA4,
|
|
0x1EA6, 0x1EA8, 0x1EAA, 0x1EAC, 0x1EAE, 0x1EB0, 0x1EB2, 0x1EB4, 0x1EB6, 0x1EB8,
|
|
0x1EBA, 0x1EBC, 0x1EBE, 0x1EC0, 0x1EC2, 0x1EC4, 0x1EC6, 0x1EC8, 0x1ECA, 0x1ECC,
|
|
0x1ECE, 0x1ED0, 0x1ED2, 0x1ED4, 0x1ED6, 0x1ED8, 0x1EDA, 0x1EDC, 0x1EDE, 0x1EE0,
|
|
0x1EE2, 0x1EE4, 0x1EE6, 0x1EE8, 0x1EEA, 0x1EEC, 0x1EEE, 0x1EF0, 0x1EF2, 0x1EF4,
|
|
0x1EF6, 0x1EF8,*/ /*0x1F08, 0x1F09, 0x1F0A, 0x1F0B, 0x1F0C, 0x1F0D, 0x1F0E, 0x1F0F,*/
|
|
/*0x1F18, 0x1F19, 0x1F1A, 0x1F1B, 0x1F1C, 0x1F1D, 0x1F28, 0x1F29, 0x1F2A, 0x1F2B,
|
|
0x1F2C, 0x1F2D, 0x1F2E, 0x1F2F, 0x1F38, 0x1F39, 0x1F3A, 0x1F3B, 0x1F3C, 0x1F3D,
|
|
0x1F3E, 0x1F3F,*/ 0x1F48, 0x1F49, 0x1F4A, 0x1F4B, 0x1F4C, 0x1F4D, 0x1F59, 0x1F5B,
|
|
0x1F5D, 0x1F5F, 0x1F68, 0x1F69, 0x1F6A, 0x1F6B, 0x1F6C, 0x1F6D, 0x1F6E, 0x1F6F,
|
|
0x1FBA, 0x1FBB, 0x1FC8, 0x1FC9, 0x1FCA, 0x1FCB, 0x1FDA, 0x1FDB, 0x1FF8, 0x1FF9,
|
|
0x1FEA, 0x1FEB, 0x1FFA, 0x1FFB, 0x1F88, 0x1F89, 0x1F8A, 0x1F8B, 0x1F8C, 0x1F8D,
|
|
0x1F8E, 0x1F8F, 0x1F98, 0x1F99, 0x1F9A, 0x1F9B, 0x1F9C, 0x1F9D, 0x1F9E, 0x1F9F,
|
|
0x1FA8, 0x1FA9, 0x1FAA, 0x1FAB, 0x1FAC, 0x1FAD, 0x1FAE, 0x1FAF, 0x1FB8, 0x1FB9,
|
|
0x1FBC, 0x0399, 0x1FCC, 0x1FD8, 0x1FD9, 0x1FE8, 0x1FE9, 0x1FEC, 0x1FFC /*0x2160,
|
|
0x2161, 0x2162, 0x2163, 0x2164, 0x2165, 0x2166, 0x2167, 0x2168, 0x2169, 0x216A,
|
|
0x216B, 0x216C, 0x216D, 0x216E, 0x216F 0x24B6, 0x24B7, 0x24B8, 0x24B9, 0x24BA,
|
|
0x24BB, 0x24BC, 0x24BD, 0x24BE, 0x24BF, 0x24C0, 0x24C1, 0x24C2, 0x24C3, 0x24C4,
|
|
0x24C5, 0x24C6, 0x24C7, 0x24C8, 0x24C9, 0x24CA, 0x24CB, 0x24CC, 0x24CD, 0x24CE,
|
|
0x24CF 0xFF21, 0xFF22, 0xFF23, 0xFF24, 0xFF25, 0xFF26, 0xFF27, 0xFF28, 0xFF29,
|
|
0xFF2A, 0xFF2B, 0xFF2C, 0xFF2D, 0xFF2E, 0xFF2F, 0xFF30, 0xFF31, 0xFF32, 0xFF33,
|
|
0xFF34, 0xFF35, 0xFF36, 0xFF37, 0xFF38, 0xFF39, 0xFF3A*/
|
|
};
|
|
|
|
|
|
// 12sep02 grandma : table driven inline function is 14x faster than original function,
|
|
// Using first 100 movies of ATS, HashKey alone calls CharToUpper() 360,000 times.
|
|
|
|
// Only entries 0-254 are used in these tables in unicharToUpper and unicharToLower
|
|
// so entry 255 has been removed. Entry 255 is handled by the lowerCaseBase code.
|
|
|
|
static const uint8_t tolower_map[] =
|
|
{
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0-15
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //16-31
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //32-47
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //48-63
|
|
0x00, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, //64-79
|
|
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, //80-95
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //96-111
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //112-127
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //128-143
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //144-159
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //160-175
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //176-191
|
|
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, //192-207
|
|
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, //208-223
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //224-239
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 //240-254
|
|
};
|
|
|
|
static const uint8_t toupper_map[] =
|
|
{
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //0-15
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //16-31
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //32-47
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //48-63
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //64-79
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //80-95
|
|
0x00, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, //96-111
|
|
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, //112-127
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //128-143
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //144-159
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //160-175
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //176-191
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //192-207
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //208-223
|
|
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, //224-239
|
|
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 //240-254
|
|
};
|
|
|
|
|
|
// WARNING: This is used by the core flash code. Any change to this utility, or the tables
|
|
// it relies on, will break legacy Flash content.
|
|
/*static*/ uint32_t String::unicharToUpper(uint32_t ch)
|
|
{
|
|
if (ch < 0xFF)
|
|
return toupper_map[ch] ^ ch;
|
|
|
|
// offset 0x1C60
|
|
/*
|
|
if ( (ch>=0x2D00 && ch<=0x2D25) ) // Georgian
|
|
{
|
|
return (ch - 0x1C60);
|
|
}
|
|
*/
|
|
|
|
// offset 80
|
|
if ( (ch>=0x0450 && ch<=0x045F) )
|
|
{
|
|
return (ch - 0x50);
|
|
}
|
|
|
|
// offset 48
|
|
if ( (ch>=0x0561 && ch<=0x0586) )
|
|
{
|
|
return (ch - 0x30);
|
|
}
|
|
|
|
// offset -32
|
|
if ( (ch>=0x03B1 && ch<=0x03CB) ||
|
|
(ch>=0x0430 && ch<=0x044F) ||
|
|
(ch>=0xFF41 && ch<=0xFF5A) )
|
|
{
|
|
return (ch - 0x20);
|
|
}
|
|
|
|
// offset 26
|
|
if ( (ch>=0x24D0 && ch<=0x24E9) )
|
|
{
|
|
return (ch - 0x1A);
|
|
}
|
|
|
|
// offset 16
|
|
if ( (ch>=0x2170 && ch<=0x217F) )
|
|
{
|
|
return (ch - 0x10);
|
|
}
|
|
|
|
// offset +8(positive)
|
|
if ( (ch>=0x1F00 && ch<=0X1F07) ||
|
|
(ch>=0x1F10 && ch<=0x1F15) ||
|
|
(ch>=0x1F20 && ch<=0x1F27) ||
|
|
(ch>=0x1F30 && ch<=0x1F37) )
|
|
{
|
|
return (ch + 0x8);
|
|
}
|
|
|
|
// offset -1
|
|
if ( (ch>=0x0101 && ch<=0x0233) )
|
|
{
|
|
if ( ((ch<=0x012F) && (ch&0x1)) || // odd only
|
|
((ch>=0x013A && ch<=0x0148) && !(ch&0x1)) || // even only
|
|
((ch>=0x014B && ch<=0x0177) && (ch&1)) || // odd only
|
|
((ch>=0x0201 && ch<=0x0233) && (ch&1) && ch!=0x0221) ) // odd only
|
|
{
|
|
return (ch - 1);
|
|
}
|
|
}
|
|
|
|
if ( ch&1 ) // only looking for odd chars here
|
|
{
|
|
// GREEK
|
|
if ( ch>=0x03D9 && ch<=0x03EF )
|
|
return (ch - 1);
|
|
// CYRILLIC
|
|
if ( ((ch>=0x0461 && ch<=0x04BF) && !(ch==0x0483 || ch==0x0485 || ch==0x487 || ch==0x0489)) ||
|
|
(ch>=0x04D1 && ch<=0x04F9) )
|
|
{
|
|
if (ch!=0x0483 && ch!=0x0485 && ch!=0x487 && ch!=0x0489)
|
|
return (ch - 1);
|
|
}
|
|
// LATIN_EXT_ADD
|
|
if ( (ch>=0x1E01 && ch<=0x1E95) || (ch>=0x1EA1 && ch<=0x1EF9) )
|
|
return (ch - 1);
|
|
}
|
|
|
|
|
|
AvmAssert(sizeof(lowerCaseBase) == sizeof(upperCaseConversion));
|
|
|
|
uint32_t result = ch;
|
|
// Do a binary search in lowerCaseBase for char
|
|
int32_t lo = 0;
|
|
int32_t hi = (sizeof(lowerCaseBase) / sizeof(lowerCaseBase[0])) - 1;
|
|
|
|
while (lo <= hi)
|
|
{
|
|
int32_t pivot = (lo+hi)>>1;
|
|
uint32_t testChar = lowerCaseBase[pivot];
|
|
|
|
if (ch == testChar)
|
|
{
|
|
// Use that index into lowerCaseConversion for a return value
|
|
result = upperCaseConversion[pivot];
|
|
break;
|
|
}
|
|
else if (ch < testChar)
|
|
{
|
|
hi = pivot-1;
|
|
}
|
|
else
|
|
{
|
|
lo = pivot+1;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static const wchar upperCaseBase[] =
|
|
{
|
|
/*0x0100, 0x0102, 0x0104, 0x0106,
|
|
0x0108, 0x010A, 0x010C, 0x010E, 0x0110, 0x0112, 0x0114, 0x0116, 0x0118, 0x011A,
|
|
0x011C, 0x011E, 0x0120, 0x0122, 0x0124, 0x0126, 0x0128, 0x012A, 0x012C, 0x012E,*/
|
|
0x0130, 0x0132, 0x0134, 0x0136, /*0x0139, 0x013B, 0x013D, 0x013F, 0x0141, 0x0143,
|
|
0x0145, 0x0147, 0x014A, 0x014C, 0x014E, 0x0150, 0x0152, 0x0154, 0x0156, 0x0158,
|
|
0x015A, 0x015C, 0x015E, 0x0160, 0x0162, 0x0164, 0x0166, 0x0168, 0x016A, 0x016C,
|
|
0x016E, 0x0170, 0x0172, 0x0174, 0x0176,*/ 0x0178, 0x0179, 0x017B, 0x017D, 0x0181,
|
|
0x0182, 0x0184, 0x0186, 0x0187, 0x0189, 0x018A, 0x018B, 0x018E, 0x018F, 0x0190,
|
|
0x0191, 0x0193, 0x0194, 0x0196, 0x0197, 0x0198, 0x019C, 0x019D, 0x019F, 0x01A0,
|
|
0x01A2, 0x01A4, 0x01A6, 0x01A7, 0x01A9, 0x01AC, 0x01AE, 0x01AF, 0x01B1, 0x01B2,
|
|
0x01B3, 0x01B5, 0x01B7, 0x01B8, 0x01BC, 0x01C4, 0x01C5, 0x01C7, 0x01C8, 0x01CA,
|
|
0x01CB, 0x01CD, 0x01CF, 0x01D1, 0x01D3, 0x01D5, 0x01D7, 0x01D9, 0x01DB, 0x01DE,
|
|
0x01E0, 0x01E2, 0x01E4, 0x01E6, 0x01E8, 0x01EA, 0x01EC, 0x01EE, 0x01F1, 0x01F2,
|
|
0x01F4, 0x01F6, 0x01F7, 0x01F8, 0x01FA, 0x01FC, 0x01FE, /*0x0200, 0x0202, 0x0204,
|
|
0x0206, 0x0208, 0x020A, 0x020C, 0x020E, 0x0210, 0x0212, 0x0214, 0x0216, 0x0218,
|
|
0x021A, 0x021C, 0x021E, 0x0222, 0x0224, 0x0226, 0x0228, 0x022A, 0x022C, 0x022E,
|
|
0x0230, 0x0232,*/ 0x0386, 0x0388, 0x0389, 0x038A, 0x038C, 0x038E, 0x038F, /*0x0391,
|
|
0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x0398, 0x0399, 0x039A, 0x039B,
|
|
0x039C, 0x039D, 0x039E, 0x039F, 0x03A0, 0x03A1, 0x03A3, 0x03A4, 0x03A5, 0x03A6,
|
|
0x03A7, 0x03A8, 0x03A9, 0x03AA, 0x03AB, 0x03DA, 0x03DC, 0x03DE, 0x03E0, 0x03E2,
|
|
0x03E4, 0x03E6, 0x03E8, 0x03EA, 0x03EC, 0x03EE,*/ 0x03F4, /*0x0400, 0x0401, 0x0402,
|
|
0x0403, 0x0404, 0x0405, 0x0406, 0x0407, 0x0408, 0x0409, 0x040A, 0x040B, 0x040C,
|
|
0x040D, 0x040E, 0x040F,*/ /*0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416,
|
|
0x0417, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F, 0x0420,
|
|
0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042A,
|
|
0x042B, 0x042C, 0x042D, 0x042E, 0x042F, 0x0460, 0x0462, 0x0464, 0x0466, 0x0468,
|
|
0x046A, 0x046C, 0x046E, 0x0470, 0x0472, 0x0474, 0x0476, 0x0478, 0x047A, 0x047C,
|
|
0x047E, 0x0480, 0x048C, 0x048E, 0x0490, 0x0492, 0x0494, 0x0496, 0x0498, 0x049A,
|
|
0x049C, 0x049E, 0x04A0, 0x04A2, 0x04A4, 0x04A6, 0x04A8, 0x04AA, 0x04AC, 0x04AE,
|
|
0x04B0, 0x04B2, 0x04B4, 0x04B6, 0x04B8, 0x04BA, 0x04BC, 0x04BE,*/ 0x04C1, 0x04C3,
|
|
0x04C7, 0x04CB, /*0x04D0, 0x04D2, 0x04D4, 0x04D6, 0x04D8, 0x04DA, 0x04DC, 0x04DE,
|
|
0x04E0, 0x04E2, 0x04E4, 0x04E6, 0x04E8, 0x04EA, 0x04EC, 0x04EE, 0x04F0, 0x04F2,
|
|
0x04F4, 0x04F8, 0x0531, 0x0532, 0x0533, 0x0534, 0x0535, 0x0536, 0x0537, 0x0538,
|
|
0x0539, 0x053A, 0x053B, 0x053C, 0x053D, 0x053E, 0x053F, 0x0540, 0x0541, 0x0542,
|
|
0x0543, 0x0544, 0x0545, 0x0546, 0x0547, 0x0548, 0x0549, 0x054A, 0x054B, 0x054C,
|
|
0x054D, 0x054E, 0x054F, 0x0550, 0x0551, 0x0552, 0x0553, 0x0554, 0x0555, 0x0556,*/
|
|
/*
|
|
// cn: added Georgian. Not in the UnicodeData-3.2.0 spreadsheet, but was added later
|
|
0x10a0, 0x10a1, 0x10a2, 0x10a3, 0x10a4, 0x10a5, 0x10a6, 0x10a7, 0x10a8, 0x10a9,
|
|
0x10aa, 0x10ab, 0x10ac, 0x10ad, 0x10ae, 0x10af, 0x10b0, 0x10b1, 0x10b2, 0x10b3,
|
|
0x10b4, 0x10b5, 0x10b6, 0x10b7, 0x10b8, 0x10b9, 0x10ba, 0x10bb, 0x10bc, 0x10bd,
|
|
0x10be, 0x10bf, 0x10c0, 0x10c1, 0x10c2, 0x10c3, 0x10c4, 0x10c5,
|
|
// cn: end Georgian.
|
|
*/
|
|
/*0x1E00, 0x1E02, 0x1E04, 0x1E06, 0x1E08, 0x1E0A, 0x1E0C, 0x1E0E, 0x1E10, 0x1E12,
|
|
0x1E14, 0x1E16, 0x1E18, 0x1E1A, 0x1E1C, 0x1E1E, 0x1E20, 0x1E22, 0x1E24, 0x1E26,
|
|
0x1E28, 0x1E2A, 0x1E2C, 0x1E2E, 0x1E30, 0x1E32, 0x1E34, 0x1E36, 0x1E38, 0x1E3A,
|
|
0x1E3C, 0x1E3E, 0x1E40, 0x1E42, 0x1E44, 0x1E46, 0x1E48, 0x1E4A, 0x1E4C, 0x1E4E,
|
|
0x1E50, 0x1E52, 0x1E54, 0x1E56, 0x1E58, 0x1E5A, 0x1E5C, 0x1E5E, 0x1E60, 0x1E62,
|
|
0x1E64, 0x1E66, 0x1E68, 0x1E6A, 0x1E6C, 0x1E6E, 0x1E70, 0x1E72, 0x1E74, 0x1E76,
|
|
0x1E78, 0x1E7A, 0x1E7C, 0x1E7E, 0x1E80, 0x1E82, 0x1E84, 0x1E86, 0x1E88, 0x1E8A,
|
|
0x1E8C, 0x1E8E, 0x1E90, 0x1E92, 0x1E94, 0x1EA0, 0x1EA2, 0x1EA4, 0x1EA6, 0x1EA8,
|
|
0x1EAA, 0x1EAC, 0x1EAE, 0x1EB0, 0x1EB2, 0x1EB4, 0x1EB6, 0x1EB8, 0x1EBA, 0x1EBC,
|
|
0x1EBE, 0x1EC0, 0x1EC2, 0x1EC4, 0x1EC6, 0x1EC8, 0x1ECA, 0x1ECC, 0x1ECE, 0x1ED0,
|
|
0x1ED2, 0x1ED4, 0x1ED6, 0x1ED8, 0x1EDA, 0x1EDC, 0x1EDE, 0x1EE0, 0x1EE2, 0x1EE4,
|
|
0x1EE6, 0x1EE8, 0x1EEA, 0x1EEC, 0x1EEE, 0x1EF0, 0x1EF2, 0x1EF4, 0x1EF6, 0x1EF8,
|
|
0x1F08, 0x1F09, 0x1F0A, 0x1F0B, 0x1F0C, 0x1F0D, 0x1F0E, 0x1F0F, 0x1F18, 0x1F19,
|
|
0x1F1A, 0x1F1B, 0x1F1C, 0x1F1D, 0x1F28, 0x1F29, 0x1F2A, 0x1F2B, 0x1F2C, 0x1F2D,
|
|
0x1F2E, 0x1F2F, 0x1F38, 0x1F39, 0x1F3A, 0x1F3B, 0x1F3C, 0x1F3D, 0x1F3E, 0x1F3F,*/
|
|
0x1F48, 0x1F49, 0x1F4A, 0x1F4B, 0x1F4C, 0x1F4D, 0x1F59, 0x1F5B, 0x1F5D, 0x1F5F,
|
|
0x1F68, 0x1F69, 0x1F6A, 0x1F6B, 0x1F6C, 0x1F6D, 0x1F6E, 0x1F6F, 0x1F88, 0x1F89,
|
|
0x1F8A, 0x1F8B, 0x1F8C, 0x1F8D, 0x1F8E, 0x1F8F, 0x1F98, 0x1F99, 0x1F9A, 0x1F9B,
|
|
0x1F9C, 0x1F9D, 0x1F9E, 0x1F9F, 0x1FA8, 0x1FA9, 0x1FAA, 0x1FAB, 0x1FAC, 0x1FAD,
|
|
0x1FAE, 0x1FAF, 0x1FB8, 0x1FB9, 0x1FBA, 0x1FBB, 0x1FBC, 0x1FC8, 0x1FC9, 0x1FCA,
|
|
0x1FCB, 0x1FCC, 0x1FD8, 0x1FD9, 0x1FDA, 0x1FDB, 0x1FE8, 0x1FE9, 0x1FEA, 0x1FEB,
|
|
0x1FEC, 0x1FF8, 0x1FF9, 0x1FFA, 0x1FFB, 0x1FFC, 0x2126, 0x212A, 0x212B /*0x2160,
|
|
0x2161, 0x2162, 0x2163, 0x2164, 0x2165, 0x2166, 0x2167, 0x2168, 0x2169, 0x216A,
|
|
0x216B, 0x216C, 0x216D, 0x216E, 0x216F, 0x24B6, 0x24B7, 0x24B8, 0x24B9, 0x24BA,
|
|
0x24BB, 0x24BC, 0x24BD, 0x24BE, 0x24BF, 0x24C0, 0x24C1, 0x24C2, 0x24C3, 0x24C4,
|
|
0x24C5, 0x24C6, 0x24C7, 0x24C8, 0x24C9, 0x24CA, 0x24CB, 0x24CC, 0x24CD, 0x24CE,
|
|
0x24CF, 0xFF21, 0xFF22, 0xFF23, 0xFF24, 0xFF25, 0xFF26, 0xFF27, 0xFF28, 0xFF29,
|
|
0xFF2A, 0xFF2B, 0xFF2C, 0xFF2D, 0xFF2E, 0xFF2F, 0xFF30, 0xFF31, 0xFF32, 0xFF33,
|
|
0xFF34, 0xFF35, 0xFF36, 0xFF37, 0xFF38, 0xFF39, 0xFF3A*/
|
|
};
|
|
|
|
static const wchar lowerCaseConversion[] =
|
|
{
|
|
/*0x0101, 0x0103, 0x0105, 0x0107,
|
|
0x0109, 0x010B, 0x010D, 0x010F, 0x0111, 0x0113, 0x0115, 0x0117, 0x0119, 0x011B,
|
|
0x011D, 0x011F, 0x0121, 0x0123, 0x0125, 0x0127, 0x0129, 0x012B, 0x012D, 0x012F,*/
|
|
0x0069, 0x0133, 0x0135, 0x0137, /*0x013A, 0x013C, 0x013E, 0x0140, 0x0142, 0x0144,
|
|
0x0146, 0x0148, 0x014B, 0x014D, 0x014F, 0x0151, 0x0153, 0x0155, 0x0157, 0x0159,
|
|
0x015B, 0x015D, 0x015F, 0x0161, 0x0163, 0x0165, 0x0167, 0x0169, 0x016B, 0x016D,
|
|
0x016F, 0x0171, 0x0173, 0x0175, 0x0177,*/ 0x00FF, 0x017A, 0x017C, 0x017E, 0x0253,
|
|
0x0183, 0x0185, 0x0254, 0x0188, 0x0256, 0x0257, 0x018C, 0x01DD, 0x0259, 0x025B,
|
|
0x0192, 0x0260, 0x0263, 0x0269, 0x0268, 0x0199, 0x026F, 0x0272, 0x0275, 0x01A1,
|
|
0x01A3, 0x01A5, 0x0280, 0x01A8, 0x0283, 0x01AD, 0x0288, 0x01B0, 0x028A, 0x028B,
|
|
0x01B4, 0x01B6, 0x0292, 0x01B9, 0x01BD, 0x01C6, 0x01C6, 0x01C9, 0x01C9, 0x01CC,
|
|
0x01CC, 0x01CE, 0x01D0, 0x01D2, 0x01D4, 0x01D6, 0x01D8, 0x01DA, 0x01DC, 0x01DF,
|
|
0x01E1, 0x01E3, 0x01E5, 0x01E7, 0x01E9, 0x01EB, 0x01ED, 0x01EF, 0x01F3, 0x01F3,
|
|
0x01F5, 0x0195, 0x01BF, 0x01F9, 0x01FB, 0x01FD, 0x01FF, /*0x0201, 0x0203, 0x0205,
|
|
0x0207, 0x0209, 0x020B, 0x020D, 0x020F, 0x0211, 0x0213, 0x0215, 0x0217, 0x0219,
|
|
0x021B, 0x021D, 0x021F, 0x0223, 0x0225, 0x0227, 0x0229, 0x022B, 0x022D, 0x022F,
|
|
0x0231, 0x0233,*/ 0x03AC, 0x03AD, 0x03AE, 0x03AF, 0x03CC, 0x03CD, 0x03CE, /*0x03B1,
|
|
0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7, 0x03B8, 0x03B9, 0x03BA, 0x03BB,
|
|
0x03BC, 0x03BD, 0x03BE, 0x03BF, 0x03C0, 0x03C1, 0x03C3, 0x03C4, 0x03C5, 0x03C6,
|
|
0x03C7, 0x03C8, 0x03C9, 0x03CA, 0x03CB, 0x03DB, 0x03DD, 0x03DF, 0x03E1, 0x03E3,
|
|
0x03E5, 0x03E7, 0x03E9, 0x03EB, 0x03ED, 0x03EF,*/ 0x03B8, /*0x0450, 0x0451, 0x0452,
|
|
0x0453, 0x0454, 0x0455, 0x0456, 0x0457, 0x0458, 0x0459, 0x045A, 0x045B, 0x045C,
|
|
0x045D, 0x045E, 0x045F,*/ /*0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436,
|
|
0x0437, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F, 0x0440,
|
|
0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044A,
|
|
0x044B, 0x044C, 0x044D, 0x044E, 0x044F, 0x0461, 0x0463, 0x0465, 0x0467, 0x0469,
|
|
0x046B, 0x046D, 0x046F, 0x0471, 0x0473, 0x0475, 0x0477, 0x0479, 0x047B, 0x047D,
|
|
0x047F, 0x0481, 0x048D, 0x048F, 0x0491, 0x0493, 0x0495, 0x0497, 0x0499, 0x049B,
|
|
0x049D, 0x049F, 0x04A1, 0x04A3, 0x04A5, 0x04A7, 0x04A9, 0x04AB, 0x04AD, 0x04AF,
|
|
0x04B1, 0x04B3, 0x04B5, 0x04B7, 0x04B9, 0x04BB, 0x04BD, 0x04BF,*/ 0x04C2, 0x04C4,
|
|
0x04C8, 0x04CC, /*0x04D1, 0x04D3, 0x04D5, 0x04D7, 0x04D9, 0x04DB, 0x04DD, 0x04DF,
|
|
0x04E1, 0x04E3, 0x04E5, 0x04E7, 0x04E9, 0x04EB, 0x04ED, 0x04EF, 0x04F1, 0x04F3,
|
|
0x04F5, 0x04F9, 0x0561, 0x0562, 0x0563, 0x0564, 0x0565, 0x0566, 0x0567, 0x0568,
|
|
0x0569, 0x056A, 0x056B, 0x056C, 0x056D, 0x056E, 0x056F, 0x0570, 0x0571, 0x0572,
|
|
0x0573, 0x0574, 0x0575, 0x0576, 0x0577, 0x0578, 0x0579, 0x057A, 0x057B, 0x057C,
|
|
0x057D, 0x057E, 0x057F, 0x0580, 0x0581, 0x0582, 0x0583, 0x0584, 0x0585, 0x0586,*/
|
|
// cn: added Georgian. Not in the UnicodeData-3.2.0 spreadsheet, but was added later
|
|
/*
|
|
0x10d0, 0x10d1, 0x10d2, 0x10d3, 0x10d4, 0x10d5, 0x10d6, 0x10d7, 0x10d8, 0x10d9,
|
|
0x10da, 0x10db, 0x10dc, 0x10dd, 0x10de, 0x10df, 0x10e0, 0x10e1, 0x10e2, 0x10e3,
|
|
0x10e4, 0x10e5, 0x10e6, 0x10e7, 0x10e8, 0x10e9, 0x10ea, 0x10eb, 0x10ec, 0x10ed,
|
|
0x10ee, 0x10ef, 0x10f0, 0x10f1, 0x10f2, 0x10f3, 0x10f4, 0x10f5,
|
|
// cn: end Georgian.
|
|
*/
|
|
/*0x1E01, 0x1E03, 0x1E05, 0x1E07, 0x1E09, 0x1E0B, 0x1E0D, 0x1E0F, 0x1E11, 0x1E13,
|
|
0x1E15, 0x1E17, 0x1E19, 0x1E1B, 0x1E1D, 0x1E1F, 0x1E21, 0x1E23, 0x1E25, 0x1E27,
|
|
0x1E29, 0x1E2B, 0x1E2D, 0x1E2F, 0x1E31, 0x1E33, 0x1E35, 0x1E37, 0x1E39, 0x1E3B,
|
|
0x1E3D, 0x1E3F, 0x1E41, 0x1E43, 0x1E45, 0x1E47, 0x1E49, 0x1E4B, 0x1E4D, 0x1E4F,
|
|
0x1E51, 0x1E53, 0x1E55, 0x1E57, 0x1E59, 0x1E5B, 0x1E5D, 0x1E5F, 0x1E61, 0x1E63,
|
|
0x1E65, 0x1E67, 0x1E69, 0x1E6B, 0x1E6D, 0x1E6F, 0x1E71, 0x1E73, 0x1E75, 0x1E77,
|
|
0x1E79, 0x1E7B, 0x1E7D, 0x1E7F, 0x1E81, 0x1E83, 0x1E85, 0x1E87, 0x1E89, 0x1E8B,
|
|
0x1E8D, 0x1E8F, 0x1E91, 0x1E93, 0x1E95, 0x1EA1, 0x1EA3, 0x1EA5, 0x1EA7, 0x1EA9,
|
|
0x1EAB, 0x1EAD, 0x1EAF, 0x1EB1, 0x1EB3, 0x1EB5, 0x1EB7, 0x1EB9, 0x1EBB, 0x1EBD,
|
|
0x1EBF, 0x1EC1, 0x1EC3, 0x1EC5, 0x1EC7, 0x1EC9, 0x1ECB, 0x1ECD, 0x1ECF, 0x1ED1,
|
|
0x1ED3, 0x1ED5, 0x1ED7, 0x1ED9, 0x1EDB, 0x1EDD, 0x1EDF, 0x1EE1, 0x1EE3, 0x1EE5,
|
|
0x1EE7, 0x1EE9, 0x1EEB, 0x1EED, 0x1EEF, 0x1EF1, 0x1EF3, 0x1EF5, 0x1EF7, 0x1EF9,
|
|
0x1F00, 0x1F01, 0x1F02, 0x1F03, 0x1F04, 0x1F05, 0x1F06, 0x1F07, 0x1F10, 0x1F11,
|
|
0x1F12, 0x1F13, 0x1F14, 0x1F15, 0x1F20, 0x1F21, 0x1F22, 0x1F23, 0x1F24, 0x1F25,
|
|
0x1F26, 0x1F27, 0x1F30, 0x1F31, 0x1F32, 0x1F33, 0x1F34, 0x1F35, 0x1F36, 0x1F37,*/
|
|
0x1F40, 0x1F41, 0x1F42, 0x1F43, 0x1F44, 0x1F45, 0x1F51, 0x1F53, 0x1F55, 0x1F57,
|
|
0x1F60, 0x1F61, 0x1F62, 0x1F63, 0x1F64, 0x1F65, 0x1F66, 0x1F67, 0x1F80, 0x1F81,
|
|
0x1F82, 0x1F83, 0x1F84, 0x1F85, 0x1F86, 0x1F87, 0x1F90, 0x1F91, 0x1F92, 0x1F93,
|
|
0x1F94, 0x1F95, 0x1F96, 0x1F97, 0x1FA0, 0x1FA1, 0x1FA2, 0x1FA3, 0x1FA4, 0x1FA5,
|
|
0x1FA6, 0x1FA7, 0x1FB0, 0x1FB1, 0x1F70, 0x1F71, 0x1FB3, 0x1F72, 0x1F73, 0x1F74,
|
|
0x1F75, 0x1FC3, 0x1FD0, 0x1FD1, 0x1F76, 0x1F77, 0x1FE0, 0x1FE1, 0x1F7A, 0x1F7B,
|
|
0x1FE5, 0x1F78, 0x1F79, 0x1F7C, 0x1F7D, 0x1FF3, 0x03C9, 0x006B, 0x00E5 /*0x2170,
|
|
0x2171, 0x2172, 0x2173, 0x2174, 0x2175, 0x2176, 0x2177, 0x2178, 0x2179, 0x217A,
|
|
0x217B, 0x217C, 0x217D, 0x217E, 0x217F, 0x24D0, 0x24D1, 0x24D2, 0x24D3, 0x24D4,
|
|
0x24D5, 0x24D6, 0x24D7, 0x24D8, 0x24D9, 0x24DA, 0x24DB, 0x24DC, 0x24DD, 0x24DE,
|
|
0x24DF, 0x24E0, 0x24E1, 0x24E2, 0x24E3, 0x24E4, 0x24E5, 0x24E6, 0x24E7, 0x24E8,
|
|
0x24E9, 0xFF41, 0xFF42, 0xFF43, 0xFF44, 0xFF45, 0xFF46, 0xFF47, 0xFF48, 0xFF49,
|
|
0xFF4A, 0xFF4B, 0xFF4C, 0xFF4D, 0xFF4E, 0xFF4F, 0xFF50, 0xFF51, 0xFF52, 0xFF53,
|
|
0xFF54, 0xFF55, 0xFF56, 0xFF57, 0xFF58, 0xFF59, 0xFF5A*/
|
|
};
|
|
|
|
|
|
// WARNING: This is used by the core flash code. Any change to this utility, or the tables
|
|
// it relies on, will break legacy Flash content.
|
|
/*static*/ uint32_t String::unicharToLower(uint32_t ch)
|
|
{
|
|
if (ch < 0xFF)
|
|
return tolower_map[ch] ^ ch;
|
|
|
|
// offset x1C60
|
|
if( ch>=0x10A0 && ch<=0x10C5 ) // Georgian
|
|
{
|
|
return (ch + 48); // WRONG
|
|
//return (ch + 0x1C60); // CORRECT
|
|
}
|
|
|
|
// offset 80
|
|
if ( (ch>=0x0400 && ch<=0x040F) )
|
|
{
|
|
return (ch + 0x50);
|
|
}
|
|
|
|
// offset 48
|
|
if ( (ch>=0x0531 && ch<=0x0556) )
|
|
{
|
|
return (ch + 0x30);
|
|
}
|
|
|
|
// offset 32
|
|
if ( (ch>=0x0391 && ch<=0x03AB) ||
|
|
(ch>=0x0410 && ch<=0x042F) ||
|
|
(ch>=0xFF21 && ch<=0xFF3A) )
|
|
{
|
|
return (ch + 0x20);
|
|
}
|
|
|
|
// offset 26
|
|
if ( (ch>=0x24B6 && ch<=0x24CF) )
|
|
{
|
|
return (ch + 0x1A);
|
|
}
|
|
|
|
// offset 16
|
|
if ( (ch>=0x2160 && ch<=0x216F) )
|
|
{
|
|
return (ch + 0x10);
|
|
}
|
|
|
|
// offset -8(negative)
|
|
if ( (ch>=0x1F08 && ch<=0X1F0F) ||
|
|
(ch>=0x1F18 && ch<=0x1F1D) ||
|
|
(ch>=0x1F28 && ch<=0x1F2F) ||
|
|
(ch>=0x1F38 && ch<=0x1F3F) )
|
|
{
|
|
return (ch - 0x8);
|
|
}
|
|
|
|
// offset +1
|
|
if ( (ch>=0x0100 && ch<=0x0232) )
|
|
{
|
|
// only even numbers
|
|
if ( ((ch<=0x012E) && !(ch&0x1)) ||
|
|
((ch>=0x0139 && ch<=0x0147) && (ch&0x1)) ||
|
|
((ch>=0x014A && ch<=0x0176) && !(ch&1)) ||
|
|
((ch>=0x0200 && ch<=0x0232) && !(ch&1) && (ch!=0x0220)) )
|
|
{
|
|
return (ch + 1);
|
|
}
|
|
}
|
|
|
|
if ( !(ch&1) ) // only looking for even chars
|
|
{
|
|
if ( (ch>=0x03D8 && ch<=0x03EE) )
|
|
return (ch + 1);
|
|
if ( ((ch>=0x0460 && ch<=0x04BE) && !(ch==0x0482 || ch==0x0484 || ch==0x486 || ch==0x0488)) ||
|
|
(ch>=0x04D0 && ch<=0x04F8) )
|
|
{
|
|
if (ch!=0x0482 && ch!=0x0484 && ch!=0x486 && ch!=0x0488)
|
|
return (ch + 1);
|
|
}
|
|
if ( (ch>=0x1E00 && ch<=0x1E94) || (ch>=0x1EA0 && ch<=0x1EF8) )
|
|
return (ch + 1);
|
|
}
|
|
|
|
|
|
AvmAssert(sizeof(upperCaseBase) == sizeof(lowerCaseConversion));
|
|
|
|
uint32_t result = ch;
|
|
// Do a binary search in upperCaseBase for char
|
|
int32_t lo = 0;
|
|
int32_t hi = (sizeof(upperCaseBase) / sizeof(upperCaseBase[0])) - 1;
|
|
|
|
while (lo <= hi)
|
|
{
|
|
int32_t pivot = (lo+hi)>>1;
|
|
uint32_t testChar = upperCaseBase[pivot];
|
|
|
|
if (ch == testChar)
|
|
{
|
|
// Use that index into lowerCaseConversion for a return value
|
|
result = lowerCaseConversion[pivot];
|
|
break;
|
|
}
|
|
else if (ch < testChar)
|
|
{
|
|
hi = pivot-1;
|
|
}
|
|
else
|
|
{
|
|
lo = pivot+1;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
Stringp String::toUpperCase()
|
|
{
|
|
return caseChange(unicharToUpper);
|
|
}
|
|
|
|
Stringp String::toLowerCase()
|
|
{
|
|
return caseChange(unicharToLower);
|
|
}
|
|
|
|
Stringp String::caseChange(uint32_t(*unimapper)(uint32_t))
|
|
{
|
|
if (!this->length())
|
|
return this;
|
|
|
|
// Flag to detect whether any changes were made
|
|
bool changed = false;
|
|
|
|
// 0xFF is a special case: ToUpper(0xFF) == 0x178, so we need a wider string
|
|
// if the string contains 0xFF
|
|
Width w = getWidth();
|
|
if (w == k8 && VMPI_memchr(Pointers(this).p8, 0xFF, m_length) != 0)
|
|
w = k16;
|
|
|
|
GC* gc = _gc(this);
|
|
const bool is7bit = false;
|
|
Stringp newStr = createDynamic(gc, NULL, m_length, w, is7bit);
|
|
|
|
Pointers src(this); // can't re-use the Pointers from VMPI_memchr; createDynamic may have invalidated it
|
|
Pointers dst(newStr);
|
|
|
|
int32_t i;
|
|
uint32_t ch1, ch2;
|
|
if (getWidth() == k8)
|
|
{
|
|
for (i = 0; i < m_length; i++)
|
|
{
|
|
ch1 = uint32_t(*src.p8++);
|
|
ch2 = unimapper (ch1);
|
|
if (w == k16)
|
|
*dst.p16++ = wchar(ch2);
|
|
else
|
|
*dst.p8++ = uint8_t(ch2);
|
|
if (ch1 != ch2)
|
|
changed = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (i = 0; i < m_length; i++)
|
|
{
|
|
ch1 = uint32_t(*src.p16++);
|
|
ch2 = unimapper(ch1);
|
|
*dst.p16++ = wchar(ch2);
|
|
if (ch1 != ch2)
|
|
changed = true;
|
|
}
|
|
}
|
|
VERIFY_7BIT(this);
|
|
VERIFY_7BIT(newStr);
|
|
return changed ? newStr : this;
|
|
}
|
|
|
|
double String::toNumber()
|
|
{
|
|
return MathUtils::convertStringToNumber(this);
|
|
}
|
|
|
|
bool String::isWhitespace() const
|
|
{
|
|
StringIndexer self((Stringp) this);
|
|
for (int32_t i = 0 ; i < length(); i++)
|
|
{
|
|
wchar ch = self[i];
|
|
if (!isSpace(ch))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*static*/ int32_t FASTCALL String::Length(const wchar* str)
|
|
{
|
|
AvmAssert(str != NULL);
|
|
|
|
const wchar* s = str;
|
|
while (*s)
|
|
s++;
|
|
ptrdiff_t len = s - str;
|
|
if (len <= 0x7FFFFFFF)
|
|
return int32_t(len);
|
|
GCHeap::SignalObjectTooLarge();
|
|
/*NOTREACHED*/
|
|
return 0;
|
|
}
|
|
|
|
/*static*/ int32_t FASTCALL String::Length(const char* str)
|
|
{
|
|
AvmAssert(str != NULL);
|
|
|
|
size_t len = VMPI_strlen(str);
|
|
if (len <= 0x7FFFFFFF)
|
|
return int32_t(len);
|
|
GCHeap::SignalObjectTooLarge();
|
|
/*NOTREACHED*/
|
|
return 0;
|
|
}
|
|
|
|
int String::_indexOf(Stringp substr, int startPos)
|
|
{
|
|
return (int) indexOf(substr, (int32_t) startPos);
|
|
}
|
|
|
|
// Coded as a macro for best performance with MSVC 2008 32-bit
|
|
// -1 (or negative infinity) - position equals -1 (out of bounds)
|
|
// >length (or positive infinity) - position equals length
|
|
// non-NaN - integer cast to determine position
|
|
// NaN - use NaNValue (usually zero but length for lastIndexOf)
|
|
#define INTCLAMP(iPos, dPos, length, NaNValue) \
|
|
{ \
|
|
if (dPos <= -1) \
|
|
iPos = -1; \
|
|
else if (dPos >= length) \
|
|
iPos = length; \
|
|
else if (!MathUtils::isNaNInline(dPos)) { \
|
|
iPos = (int32_t) dPos; \
|
|
} \
|
|
else { \
|
|
iPos = NaNValue; \
|
|
} \
|
|
}
|
|
|
|
int32_t String::AS3_indexOf(Stringp substr, double dStartPos)
|
|
{
|
|
int32_t iPos;
|
|
INTCLAMP(iPos, dStartPos, this->length(), 0);
|
|
return indexOf(substr, iPos);
|
|
}
|
|
|
|
int String::_lastIndexOf(Stringp substr, int iStartPos)
|
|
{
|
|
return (int) lastIndexOf(substr, (int32_t) iStartPos);
|
|
}
|
|
|
|
int32_t String::AS3_lastIndexOf(Stringp substr, double dStartPos)
|
|
{
|
|
// unlike most other calls, this one has nan->length rather than nan->0
|
|
int32_t iStartPos;
|
|
INTCLAMP(iStartPos, dStartPos, this->length(), this->length());
|
|
return lastIndexOf(substr, iStartPos);
|
|
}
|
|
|
|
Stringp String::_substr(int start, int count)
|
|
{
|
|
int len = this->length();
|
|
start = (int)NativeObjectHelpers::ClampIndexInt(start, len);
|
|
// ClampIndex takes a double (not int or uint) for first parm...
|
|
// we must cast these to double before addition, otherwise we
|
|
// can have numeric overflow with the default arg (end=0x7fffffff)
|
|
// and wrap to negative, which would be bad...
|
|
|
|
// Do some sanity checks on our ints to see if they will fall within a valid integer range
|
|
// !!@what about negative values?
|
|
int end;
|
|
if (count == 0x7fffffff) // largest positive int value, also the default arg
|
|
{
|
|
end = len;
|
|
}
|
|
else if ((count > 0x3fffffff) || (start > 0x3fffffff)) // might overflow - use doubles
|
|
{
|
|
end = (int)NativeObjectHelpers::ClampIndex(double(count) + double(start), len);
|
|
}
|
|
else
|
|
{
|
|
end = (int)NativeObjectHelpers::ClampIndexInt(count + start, len);
|
|
}
|
|
|
|
if (end < start)
|
|
end = start;
|
|
|
|
return substr(start, end-start);
|
|
}
|
|
|
|
Stringp String::AS3_substr(double d_start, double d_count)
|
|
{
|
|
int32_t len = this->length();
|
|
int32_t start = (int32_t) NativeObjectHelpers::ClampIndex(MathUtils::toInt(d_start), len);
|
|
// ClampIndex takes a double (not int or uint) for first parm...
|
|
// we must cast these to double before addition, otherwise we
|
|
// can have numeric overflow with the default arg (end=0x7fffffff)
|
|
// and wrap to negative, which would be bad...
|
|
int32_t end = (int32_t)NativeObjectHelpers::ClampIndex(MathUtils::toInt(d_count) + (double)start, len);
|
|
if (end < start)
|
|
end = start;
|
|
|
|
return substr(start, end-start);
|
|
}
|
|
|
|
Stringp String::_substring(int start, int end)
|
|
{
|
|
NativeObjectHelpers::ClampBInt(start, end, this->length());
|
|
return substring((int32_t) start, (int32_t) end);
|
|
}
|
|
|
|
Stringp String::AS3_substring(double d_start, double d_end)
|
|
{
|
|
double start = MathUtils::toInt(d_start);
|
|
double end = MathUtils::toInt(d_end);
|
|
NativeObjectHelpers::ClampB(start, end, length());
|
|
return substring((int32_t) start, (int32_t) end);
|
|
}
|
|
|
|
Stringp String::_slice(int start, int end)
|
|
{
|
|
return slice((int32_t) start, (int32_t) end);
|
|
}
|
|
|
|
Stringp String::AS3_slice(double d_start, double d_end)
|
|
{
|
|
int32_t len = this->length();
|
|
int32_t start = (int32_t)NativeObjectHelpers::ClampIndex(MathUtils::toInt(d_start), len);
|
|
int32_t end = (int32_t)NativeObjectHelpers::ClampIndex(MathUtils::toInt(d_end), len);
|
|
if (end < start)
|
|
end = start;
|
|
|
|
return substring(start, end);
|
|
}
|
|
|
|
Stringp String::_charAtI(int32_t iPos)
|
|
{
|
|
AvmCore* core = _core(this);
|
|
// use unsigned compare as faster equivalent to >= 0 && < m_length
|
|
if (uint32_t(iPos) < uint32_t(m_length)) {
|
|
Pointers ptrs(this);
|
|
wchar const ch = (wchar) (getWidth() == k8) ? ptrs.p8[iPos] : ptrs.p16[iPos];
|
|
|
|
// newStringUTF16 does the cachedChar optimization internally, but short-circuiting the test
|
|
// here is worthwhile because it's a pretty common case
|
|
if (ch < 128)
|
|
return core->cachedChars[ch];
|
|
return core->newStringUTF16(&ch, 1);
|
|
}
|
|
else {
|
|
return core->kEmptyString;
|
|
}
|
|
}
|
|
|
|
Stringp String::_charAtU(uint32_t iPos)
|
|
{
|
|
AvmCore* core = _core(this);
|
|
if (iPos < uint32_t(m_length)) {
|
|
Pointers ptrs(this);
|
|
wchar const ch = (wchar) (getWidth() == k8) ? ptrs.p8[iPos] : ptrs.p16[iPos];
|
|
|
|
// newStringUTF16 does the cachedChar optimization internally, but short-circuiting the test
|
|
// here is worthwhile because it's a pretty common case
|
|
if (ch < 128)
|
|
return core->cachedChars[ch];
|
|
return core->newStringUTF16(&ch, 1);
|
|
}
|
|
else {
|
|
return core->kEmptyString;
|
|
}
|
|
}
|
|
|
|
Stringp String::AS3_charAt(double dPos)
|
|
{
|
|
int32_t iPos;
|
|
INTCLAMP(iPos, dPos, this->length(), 0);
|
|
|
|
AvmCore* core = _core(this);
|
|
// use unsigned compare as faster equivalent to >= 0 && < m_length
|
|
if (uint32_t(iPos) < uint32_t(m_length)) {
|
|
Pointers ptrs(this);
|
|
wchar const ch = (wchar) (getWidth() == k8) ? ptrs.p8[iPos] : ptrs.p16[iPos];
|
|
|
|
// newStringUTF16 does the cachedChar optimization internally, but short-circuiting the test
|
|
// here is worthwhile because it's a pretty common case
|
|
if (ch < 128)
|
|
return core->cachedChars[ch];
|
|
return core->newStringUTF16(&ch, 1);
|
|
}
|
|
else {
|
|
return core->kEmptyString;
|
|
}
|
|
}
|
|
|
|
Stringp String::AS3_toUpperCase()
|
|
{
|
|
return toUpperCase();
|
|
}
|
|
|
|
Stringp String::AS3_toLowerCase()
|
|
{
|
|
return toLowerCase();
|
|
}
|
|
|
|
double String::_charCodeAtDI(int32_t iPos)
|
|
{
|
|
double d;
|
|
// use unsigned compare as faster equivalent to >= 0 && < m_length
|
|
if (uint32_t(iPos) < uint32_t(m_length)) {
|
|
Pointers ptrs(this);
|
|
d = (double) ((getWidth() == k8) ? ptrs.p8[iPos] : ptrs.p16[iPos]);
|
|
}
|
|
else
|
|
d = MathUtils::kNaN;
|
|
return d;
|
|
}
|
|
|
|
int32_t String::_charCodeAtII(int32_t iPos)
|
|
{
|
|
// use unsigned compare as faster equivalent to >= 0 && < m_length
|
|
if (uint32_t(iPos) < uint32_t(m_length)) {
|
|
Pointers ptrs(this);
|
|
return (getWidth() == k8) ? ptrs.p8[iPos] : ptrs.p16[iPos];
|
|
}
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
double String::_charCodeAtDU(uint32_t iPos)
|
|
{
|
|
double d;
|
|
if (iPos < uint32_t(m_length)) {
|
|
Pointers ptrs(this);
|
|
d = (double) ((getWidth() == k8) ? ptrs.p8[iPos] : ptrs.p16[iPos]);
|
|
}
|
|
else
|
|
d = MathUtils::kNaN;
|
|
return d;
|
|
}
|
|
|
|
int32_t String::_charCodeAtIU(uint32_t iPos)
|
|
{
|
|
if (iPos < uint32_t(m_length)) {
|
|
Pointers ptrs(this);
|
|
return (getWidth() == k8) ? ptrs.p8[iPos] : ptrs.p16[iPos];
|
|
}
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
double String::AS3_charCodeAt(double dPos)
|
|
{
|
|
int32_t iPos;
|
|
INTCLAMP(iPos, dPos, m_length, 0);
|
|
// use unsigned compare as faster equivalent to >= 0 && < m_length
|
|
if (uint32_t(iPos) < uint32_t(m_length)) {
|
|
Pointers ptrs(this);
|
|
return (double) ((getWidth() == k8) ? ptrs.p8[iPos] : ptrs.p16[iPos]);
|
|
}
|
|
else
|
|
return MathUtils::kNaN;
|
|
}
|
|
|
|
int32_t String::_charCodeAtID(double dPos)
|
|
{
|
|
int32_t iPos;
|
|
INTCLAMP(iPos, dPos, m_length, 0);
|
|
// use unsigned compare as faster equivalent to >= 0 && < m_length
|
|
if (uint32_t(iPos) < uint32_t(m_length)) {
|
|
Pointers ptrs(this);
|
|
return (getWidth() == k8) ? ptrs.p8[iPos] : ptrs.p16[iPos];
|
|
}
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
int32_t String::AS3_localeCompare(Atom other)
|
|
{
|
|
Stringp otherStr;
|
|
|
|
if (AvmCore::isString(other))
|
|
{
|
|
otherStr = AvmCore::atomToString(other);
|
|
}
|
|
else
|
|
{
|
|
AvmCore* core = _core(this);
|
|
|
|
// legacy behavior special-cases NULL (including undefined).
|
|
if (AvmCore::isNullOrUndefined(other))
|
|
{
|
|
if (!core->currentBugCompatibility()->bugzilla585791)
|
|
return (m_length == 0) ? 1 : 0;
|
|
}
|
|
|
|
// Proper ECMAScript behavior:
|
|
// The 'this' object is converted to string, call it a.
|
|
// The argument is converted to string, call it b.
|
|
// Those strings are compared and a string comparison value is returned.
|
|
otherStr = core->string(other);
|
|
}
|
|
|
|
return otherStr->Compare(*this);
|
|
}
|
|
|
|
#ifdef DEBUGGER
|
|
uint64_t String::bytesUsed() const
|
|
{
|
|
uint64_t bytesUsed = sizeof(String);
|
|
|
|
// If getType() == kDependent, the buffer's memory is account for by
|
|
// the string upon which this string depends, so we should not include
|
|
// it here.
|
|
//
|
|
// If getType() == kStatic, the buffer's memory is not on the GC heap,
|
|
// and freeing the string would not free the buffer, so we should not
|
|
// include its size here.
|
|
if (getType() == kDynamic)
|
|
bytesUsed += GC::Size(m_buffer.pv);
|
|
|
|
return bytesUsed;
|
|
}
|
|
|
|
Stringp String::getMasterString() const
|
|
{
|
|
if (isDependent())
|
|
return m_extra.master;
|
|
else
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
////////////////////////////// Helpers: Width Analysis /////////////////////////////////
|
|
|
|
// The character widths structure used by the _analyze() functions below
|
|
|
|
struct StringWidths
|
|
{
|
|
int32_t ascii, w8, w16, w32;
|
|
};
|
|
|
|
// Analyze a UTF-8 string buffer and find out about the character widths.
|
|
// Return false if the string contains malformed or too big sequences,
|
|
// and strict mode is requested.
|
|
|
|
// RFC 2279
|
|
|
|
// 0000 0000-0000 007F 0xxxxxxx
|
|
// 0000 0080-0000 07FF 110xxxxx 10xxxxxx
|
|
// 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx
|
|
|
|
// 0001 0000-001F FFFF 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
|
|
// 0020 0000-03FF FFFF 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
|
|
// 0400 0000-7FFF FFFF 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
|
|
|
|
static bool _analyzeUtf8(const utf8_t* in, int32_t inLen, StringWidths& r, bool strict)
|
|
{
|
|
r.ascii = r.w8 = r.w16 = r.w32 = 0;
|
|
while (inLen > 0)
|
|
{
|
|
uint32_t c = uint32_t (*in);
|
|
|
|
switch (c >> 4)
|
|
{
|
|
case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
|
|
r.w8++;
|
|
r.ascii++;
|
|
in++;
|
|
inLen--;
|
|
break;
|
|
|
|
case 12: case 13:
|
|
// 110xxxxx 10xxxxxx
|
|
if (inLen < 2) {
|
|
// Invalid
|
|
goto invalid;
|
|
}
|
|
if ((in[1]&0xC0) != 0x80) {
|
|
// Invalid
|
|
goto invalid;
|
|
}
|
|
c = (((c<<6) & 0x7C0) | (in[1] & 0x3F));
|
|
if (c < 0x80) {
|
|
// Overlong sequence, reject as invalid.
|
|
goto invalid;
|
|
}
|
|
in += 2;
|
|
inLen -= 2;
|
|
if (c < 0xFF)
|
|
r.w8++;
|
|
else
|
|
r.w16++;
|
|
break;
|
|
|
|
case 14:
|
|
// 1110xxxx 10xxxxxx 10xxxxxx
|
|
if (inLen < 3) {
|
|
// Invalid
|
|
goto invalid;
|
|
}
|
|
if ((in[1]&0xC0) != 0x80 || (in[2]&0xC0) != 0x80) {
|
|
// Invalid
|
|
goto invalid;
|
|
}
|
|
c = (((c<<12) & 0xF000) | ((in[1]<<6) & 0xFC0) | (in[2] & 0x3F));
|
|
if (c < 0x800) {
|
|
// Overlong sequence, reject as invalid.
|
|
goto invalid;
|
|
}
|
|
in += 3;
|
|
inLen -= 3;
|
|
r.w16++;
|
|
break;
|
|
|
|
case 15:
|
|
// 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
|
|
// 111110xx ... is always invalid
|
|
// 1111110x ... is always invalid
|
|
// note: when 'strict' is false, we need to mimic the behavior of FP9/FP10,
|
|
// which did not do the c&8 test. so skip it for bug-compatibility.
|
|
if ((strict && (c & 0x08)) || (inLen < 4)) {
|
|
// Invalid
|
|
goto invalid;
|
|
}
|
|
if ((in[1]&0xC0) != 0x80 ||
|
|
(in[2]&0xC0) != 0x80 ||
|
|
(in[3]&0xC0) != 0x80)
|
|
{
|
|
goto invalid;
|
|
}
|
|
|
|
c = (((c<<18) & 0x1C0000) |
|
|
((in[1]<<12) & 0x3F000) |
|
|
((in[2]<<6) & 0xFC0) |
|
|
(in[3] & 0x3F));
|
|
if (c < 0x10000) {
|
|
// Overlong sequence, reject as invalid.
|
|
goto invalid;
|
|
}
|
|
in += 4;
|
|
inLen -= 4;
|
|
r.w32++;
|
|
break;
|
|
|
|
default:
|
|
invalid:
|
|
// if non-strict, simply treat as character
|
|
if (strict)
|
|
return false;
|
|
else
|
|
{
|
|
r.w8++;
|
|
in++;
|
|
inLen--;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Analyze a UTF-16 string buffer and find out about the character widths.
|
|
// chars >= 0x10000 are encoded as 0xD800 + (upper 10 bits) and 0xDC00 + (lower 10 bits)
|
|
// Returns false in strict mode if a starting surrogate pair character is not followed
|
|
// by a correct 2nd pair character
|
|
|
|
static bool _analyzeUtf16(const wchar* p, int32_t len, StringWidths& r, bool strict)
|
|
{
|
|
r.ascii = r.w8 = r.w16 = r.w32 = 0;
|
|
while (len-- > 0)
|
|
{
|
|
wchar ch = *p++;
|
|
if (ch <= 0x7F)
|
|
r.ascii++;
|
|
if (ch <= 0xFF)
|
|
r.w8++;
|
|
else if (ch < 0xD800 || ch > 0xDBFF)
|
|
r.w16++;
|
|
else
|
|
{
|
|
if (len == 0 || *p < 0xDC00 || *p > 0xDFFF)
|
|
{
|
|
if (strict)
|
|
return false;
|
|
// found one or two characters depending on whether the 2nd surrpgate character was present
|
|
r.w16 += len ? 2 : 1;
|
|
}
|
|
else
|
|
r.w32++;
|
|
p++; len--;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Create a string out of an UTF-8 buffer.
|
|
Stringp String::createUTF8
|
|
(AvmCore* core, const utf8_t* buffer, int32_t len, Width desiredWidth, bool staticBuf, bool strict)
|
|
{
|
|
if (buffer == NULL)
|
|
{
|
|
len = 0;
|
|
buffer = &k_zero.u8;
|
|
staticBuf = true;
|
|
}
|
|
if (len < 0)
|
|
len = Length((const char*)buffer);
|
|
|
|
// determine the string width to use
|
|
StringWidths widths;
|
|
if (!_analyzeUtf8(buffer, len, widths, strict))
|
|
{
|
|
// TODO: bad character sequence error
|
|
AvmAssert(!"bad UTF8 character sequence");
|
|
return NULL;
|
|
}
|
|
|
|
if (desiredWidth == kAuto)
|
|
{
|
|
if (widths.w32 != 0 || widths.w16 != 0)
|
|
desiredWidth = String::k16;
|
|
else
|
|
desiredWidth = String::k8;
|
|
}
|
|
|
|
if (desiredWidth == String::k8 && core->kEmptyString != NULL)
|
|
{
|
|
// core has been initialized, check for cached characters
|
|
if (len == 0)
|
|
return core->kEmptyString;
|
|
|
|
if (len == 1 && *buffer < 128)
|
|
return core->cachedChars[*buffer];
|
|
}
|
|
|
|
const bool is7bit = (widths.ascii == widths.w8) && !widths.w16 && !widths.w32;
|
|
|
|
Stringp s = NULL;
|
|
GC* gc = core->GetGC();
|
|
if (desiredWidth == k8)
|
|
{
|
|
if (widths.w16 != 0 || widths.w32 != 0)
|
|
// cannot do 8-bit string with this data
|
|
// TODO: string-too-wide error
|
|
s = NULL;
|
|
else if (staticBuf && is7bit)
|
|
{
|
|
// works, because we only have 7-bit ASCII
|
|
s = createStatic(gc, buffer, widths.w8, String::k8, is7bit);
|
|
}
|
|
else
|
|
{
|
|
s = createDynamic(gc, buffer, widths.w8, String::k8, is7bit);
|
|
uint32_t uch;
|
|
int32_t bytesRead;
|
|
Pointers dst(s); // NB, we assume that Utf8ToUcs4 doesn't allocate memory!
|
|
bool bugzilla609416 = core->currentBugCompatibility()->bugzilla609416;
|
|
while (len > 0)
|
|
{
|
|
if (*((int8_t*) buffer) > 0)
|
|
{
|
|
// ASCII
|
|
*dst.p8++ = char (*buffer++);
|
|
len--;
|
|
}
|
|
else
|
|
{
|
|
bytesRead = UnicodeUtils::Utf8ToUcs4(buffer, len, &uch, bugzilla609416);
|
|
if (bytesRead == 0)
|
|
{
|
|
// invalid sequence (only if strict was false)
|
|
*dst.p8++ = char (*buffer++);
|
|
len--;
|
|
}
|
|
else
|
|
{
|
|
buffer += bytesRead;
|
|
len -= bytesRead;
|
|
*dst.p8++ = char (uch);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// surrogate pairs need 2 characters
|
|
s = createDynamic(gc, NULL, int32AddChecked(int32AddChecked(widths.w8, widths.w16), int32AddChecked(widths.w32, widths.w32)), String::k16, is7bit);
|
|
int32_t const convertedlen = UnicodeUtils::Utf8ToUtf16(buffer, len, s->m_buffer.p16, s->m_length, strict);
|
|
// if this assert fires, _analyzeUtf8 didn't agree with UnicodeUtils::Utf8ToUtf16, which is bad.
|
|
AvmAssert(convertedlen == s->m_length);
|
|
if (convertedlen < 0)
|
|
return NULL;
|
|
}
|
|
VERIFY_7BIT(s);
|
|
return s;
|
|
}
|
|
|
|
// Create a string out of an UTF-16 buffer.
|
|
Stringp String::createUTF16
|
|
(AvmCore* core, const wchar* buffer, int32_t len, Width desiredWidth, bool staticBuf, bool strict)
|
|
{
|
|
if (buffer == NULL)
|
|
{
|
|
len = 0;
|
|
buffer = &k_zero.u16;
|
|
staticBuf = true;
|
|
}
|
|
if (len < 0)
|
|
len = Length(buffer);
|
|
|
|
bool is7bit = false;
|
|
int32_t stringLength = len;
|
|
if (desiredWidth != k16)
|
|
{
|
|
// determine the string width to use
|
|
StringWidths widths;
|
|
if (!_analyzeUtf16(buffer, len, widths, strict))
|
|
{
|
|
// TODO: bad character sequence error
|
|
return NULL;
|
|
}
|
|
|
|
if (desiredWidth == kAuto)
|
|
{
|
|
if (widths.w32 != 0 || widths.w16 != 0)
|
|
desiredWidth = k16;
|
|
else
|
|
desiredWidth = k8;
|
|
}
|
|
else if (desiredWidth == k8 && (widths.w16 != 0 || widths.w32 != 0))
|
|
// cannot do 8-bit string with this data
|
|
// TODO: string-too-wide error
|
|
return NULL;
|
|
|
|
is7bit = (widths.ascii == widths.w8) && !widths.w16 && !widths.w32;
|
|
}
|
|
|
|
if (desiredWidth == k8 && core->kEmptyString != NULL)
|
|
{
|
|
// core has been initialized, check for cached characters
|
|
if (len == 0)
|
|
return core->kEmptyString;
|
|
|
|
if (len == 1 && *buffer < 128)
|
|
return core->cachedChars[*buffer];
|
|
}
|
|
|
|
if (desiredWidth == k16 && staticBuf)
|
|
{
|
|
return createStatic(core->GetGC(), buffer, len, k16, is7bit);
|
|
}
|
|
|
|
// found the width to use, now create that string
|
|
Stringp s = createDynamic(core->GetGC(), NULL, stringLength, desiredWidth, is7bit);
|
|
|
|
String::Pointers ptrs(s);
|
|
if (desiredWidth == k8)
|
|
{
|
|
while (len-- > 0)
|
|
*ptrs.p8++ = (char) *buffer++;
|
|
}
|
|
else
|
|
{
|
|
VMPI_memcpy(ptrs.pv, buffer, len << desiredWidth);
|
|
}
|
|
VERIFY_7BIT(s);
|
|
return s;
|
|
}
|
|
|
|
PrintWriter& String::print(PrintWriter& prw) const
|
|
{
|
|
if (getWidth() == k8 && (m_bitsAndFlags & TSTR_7BIT_FLAG))
|
|
{
|
|
// fast form
|
|
Pointers ptrs(this);
|
|
prw.writeN( (const char*)ptrs.p8, m_length );
|
|
}
|
|
else
|
|
{
|
|
for (int32_t i=0, n=length(); i<n; i++)
|
|
{
|
|
prw << (wchar)charAt(i);
|
|
}
|
|
}
|
|
return prw;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// 0000 0000-0000 007F 0xxxxxxx
|
|
// 0000 0080-0000 07FF 110xxxxx 10xxxxxx
|
|
// 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx
|
|
|
|
// 0001 0000-001F FFFF 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
|
|
// 0020 0000-03FF FFFF 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
|
|
// 0400 0000-7FFF FFFF 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
|
|
|
|
StUTF8String::StUTF8String(Stringp str)
|
|
{
|
|
if (!str || !str->length())
|
|
{
|
|
m_buffer = &k_zero.c8;
|
|
m_length = 0;
|
|
return;
|
|
}
|
|
|
|
VERIFY_7BIT(str);
|
|
|
|
int32_t len = 0;
|
|
|
|
MMgc::GC* gc = _gc(str);
|
|
if (str->getWidth() == String::k8)
|
|
{
|
|
len = str->m_length;
|
|
|
|
// if we know it's 7-bit, we don't need to walk it.
|
|
if (!(str->m_bitsAndFlags & String::TSTR_7BIT_FLAG))
|
|
{
|
|
const uint8_t* srcBuf = String::Pointers(str).p8;
|
|
int32_t auxchars = 0;
|
|
for (int32_t i = str->m_length; i--;)
|
|
auxchars += (*srcBuf++ > 127);
|
|
|
|
len = int32AddChecked(len, auxchars);
|
|
|
|
// no hi bits? set the bit!
|
|
if (len == str->m_length)
|
|
str->m_bitsAndFlags |= String::TSTR_7BIT_FLAG;
|
|
}
|
|
|
|
// Deliberately using gc'ed memory here (not mmfx, unmanaged memory)
|
|
// so that longjmp's past our dtor won't cause a long-term leak
|
|
char* dstBuf = (char*)gc->Alloc(uint32_t(len)+1, 0);
|
|
// can't re-use the Pointers from 7BIT above; gc->Alloc may have invalidated it
|
|
const uint8_t* srcBuf = String::Pointers(str).p8;
|
|
m_buffer = dstBuf;
|
|
m_length = len;
|
|
|
|
if (len == str->m_length)
|
|
{
|
|
VMPI_memcpy(dstBuf, srcBuf, len);
|
|
dstBuf[len] = 0;
|
|
}
|
|
else
|
|
{
|
|
for (int32_t i = str->m_length; i--;)
|
|
{
|
|
wchar ch = wchar(*srcBuf++);
|
|
if (ch >= 128)
|
|
{
|
|
*dstBuf++ = char(0xC0 + ((ch >> 6) & 0x3));
|
|
ch = 0x80 + (ch & 0x3F);
|
|
// fall thru
|
|
}
|
|
*dstBuf++ = char(ch);
|
|
}
|
|
AvmAssert(dstBuf - m_buffer == len);
|
|
*dstBuf = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
len = UnicodeUtils::Utf16ToUtf8(String::Pointers(str).p16, str->length(), NULL, 0);
|
|
if (len < 0)
|
|
len = 0;
|
|
char* dstBuf = (char*) gc->Alloc(uint32_t(len)+1, 0);
|
|
m_buffer = dstBuf;
|
|
m_length = len;
|
|
dstBuf[len] = 0;
|
|
// can't re-use the Pointers from Utf16ToUtf8 above; gc->Alloc may have invalidated it
|
|
UnicodeUtils::Utf16ToUtf8(String::Pointers(str).p16, str->length(), (uint8_t*) dstBuf, len);
|
|
}
|
|
}
|
|
|
|
StUTF8String::~StUTF8String()
|
|
{
|
|
if (m_buffer != &k_zero.c8) {
|
|
// StrUTF8String is only ever stack allocated so it's OK just to free m_buffer without NULLing it first.
|
|
GC::GetGC(m_buffer)->Free(m_buffer);
|
|
}
|
|
}
|
|
|
|
StUTF16String::StUTF16String(Stringp str)
|
|
{
|
|
if (!str || !str->length())
|
|
{
|
|
m_length = 0;
|
|
m_buffer = &k_zero.u16;
|
|
return;
|
|
}
|
|
|
|
VERIFY_7BIT(str);
|
|
|
|
MMgc::GC* gc = _gc(str);
|
|
|
|
m_length = str->m_length;
|
|
// Deliberately using gc'ed memory here (not mmfx, unmanaged memory)
|
|
// so that longjmp's past our dtor won't cause a long-term leak
|
|
wchar* dst = (wchar*) gc->Alloc(uint32ShlChecked(uint32_t(m_length)+1, String::k16), 0);
|
|
m_buffer = dst;
|
|
dst[m_length] = 0;
|
|
String::Pointers ptrs(str);
|
|
_copyBuffers(ptrs.pv, dst, m_length, str->getWidth(), String::k16);
|
|
}
|
|
|
|
StUTF16String::~StUTF16String()
|
|
{
|
|
if (m_buffer != &k_zero.u16) {
|
|
// StrUTF16String is only ever stack allocated so it's OK just to free m_buffer without NULLing it first.
|
|
GC::GetGC(m_buffer)->Free(m_buffer);
|
|
}
|
|
}
|
|
|
|
// The following table is the length of an UTF-8 sequence, indexed by the
|
|
// first character masked with 0x3F. It is assumed that the data is good
|
|
// UTF-8, which is true, since we just created it :) The table is only
|
|
// used for characters >= 0x80.
|
|
// 0000 0080-0000 07FF 000xxxxx
|
|
// 0000 0800-0000 FFFF 0010xxxx
|
|
// 0001 0000-001F FFFF 00110xxx
|
|
// 0020 0000-03FF FFFF 001110xx
|
|
// 0400 0000-7FFF FFFF 0011110x
|
|
|
|
static const uint8_t utf8Lengths[64] =
|
|
{
|
|
2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
|
|
2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
|
|
3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
|
|
4,4,4,4,4,4,4,4,5,5,5,5,6,6,6,6
|
|
};
|
|
|
|
StIndexableUTF8String::StIndexableUTF8String(Stringp s) :
|
|
StUTF8String(s),
|
|
m_lastPos(0),
|
|
m_lastUtf8Pos(0)
|
|
{
|
|
m_indexable = (s->length() == this->length()); // can't init in init-list, generates warning :-(
|
|
}
|
|
|
|
int32_t StIndexableUTF8String::toUtf8Index(int32_t pos)
|
|
{
|
|
if (pos <= 0 || pos >= length() || m_indexable)
|
|
return pos;
|
|
|
|
// optimization: these two members kick in if this method
|
|
// is called for positions in ascending order (which pcre usually does)
|
|
if (pos < m_lastPos)
|
|
m_lastPos = m_lastUtf8Pos = 0;
|
|
|
|
int32_t utf8Pos = m_lastUtf8Pos;
|
|
|
|
const utf8_t* p = (const utf8_t*) this->c_str() + m_lastUtf8Pos;
|
|
for (int32_t i = m_lastPos; i < pos; i++)
|
|
{
|
|
utf8_t ch = *p;
|
|
if (ch < 128)
|
|
p++, utf8Pos++; // ASCII
|
|
else
|
|
{
|
|
int32_t len = utf8Lengths[ch & 0x3F];
|
|
p += len;
|
|
utf8Pos += len;
|
|
}
|
|
}
|
|
m_lastPos = pos;
|
|
m_lastUtf8Pos = utf8Pos;
|
|
return utf8Pos;
|
|
}
|
|
|
|
int32_t StIndexableUTF8String::toIndex(int32_t utf8Pos)
|
|
{
|
|
if (utf8Pos <= 0 || m_indexable)
|
|
return utf8Pos;
|
|
|
|
// optimization: these two members kick in if this method
|
|
// is called for positions in ascending order (which pcre usually does)
|
|
if (utf8Pos < m_lastUtf8Pos)
|
|
m_lastPos = m_lastUtf8Pos = 0;
|
|
|
|
int32_t i = m_lastUtf8Pos;
|
|
int32_t pos = m_lastPos;
|
|
|
|
const utf8_t* p = (const utf8_t*) this->c_str() + m_lastUtf8Pos;
|
|
while (i < utf8Pos)
|
|
{
|
|
if (i >= length())
|
|
break;
|
|
utf8_t ch = *p;
|
|
if (!(ch & 0x80))
|
|
i++, p++; // ASCII
|
|
else
|
|
{
|
|
int32_t len = utf8Lengths[ch & 0x3F];
|
|
i += len;
|
|
p += len;
|
|
}
|
|
pos++;
|
|
}
|
|
m_lastPos = pos;
|
|
m_lastUtf8Pos = utf8Pos;
|
|
return pos;
|
|
}
|
|
|
|
} // end namespace avmplus
|