1230 lines
48 KiB
C++
1230 lines
48 KiB
C++
/* ***** BEGIN LICENSE BLOCK *****
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
*
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
* http://www.mozilla.org/MPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
* for the specific language governing rights and limitations under the
|
|
* License.
|
|
*
|
|
* The Original Code is [Open Source Virtual Machine.].
|
|
*
|
|
* The Initial Developer of the Original Code is
|
|
* Adobe System Incorporated.
|
|
* Portions created by the Initial Developer are Copyright (C) 1993-2006
|
|
* the Initial Developer. All Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
* Adobe AS3 Team
|
|
*
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
* the provisions above, a recipient may use your version of this file under
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
*
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
|
|
#include "avmplus.h"
|
|
|
|
namespace avmplus
|
|
{
|
|
using namespace MMgc;
|
|
|
|
int String::Length(const wchar *str)
|
|
{
|
|
if (!str)
|
|
return 0;
|
|
|
|
int len = 0;
|
|
while (*str) {
|
|
len++;
|
|
str++;
|
|
}
|
|
return len;
|
|
}
|
|
|
|
int String::Length(const char *str)
|
|
{
|
|
if (!str)
|
|
return 0;
|
|
|
|
int len = 0;
|
|
while (*str) {
|
|
len++;
|
|
str++;
|
|
}
|
|
return len;
|
|
}
|
|
|
|
// create empty string ready to be filled in
|
|
String::String(int len)
|
|
#ifdef DEBUGGER
|
|
: AvmPlusScriptableObject(kStringType)
|
|
#endif // DEBUGGER
|
|
{
|
|
AvmAssert(len >= 0);
|
|
MMGC_MEM_TYPE(this);
|
|
setBuf(allocBuf(len));
|
|
m_length = len;
|
|
}
|
|
|
|
// decode utf8
|
|
String::String(const char *str, int utf8len, int utf16len)
|
|
#ifdef DEBUGGER
|
|
: AvmPlusScriptableObject(kStringType)
|
|
#endif // DEBUGGER
|
|
{
|
|
AvmAssert(utf8len >= 0);
|
|
AvmAssert(utf16len >= 0);
|
|
|
|
MMGC_MEM_TYPE(this);
|
|
setBuf(allocBuf(utf16len));
|
|
m_length = UnicodeUtils::Utf8ToUtf16((const uint8 *)str, utf8len,
|
|
getData(), utf16len);
|
|
AvmAssert(m_length >= 0);
|
|
getData()[m_length] = 0;
|
|
}
|
|
|
|
// convert c-style wstring to String
|
|
String::String(const wchar *str, int len)
|
|
#ifdef DEBUGGER
|
|
: AvmPlusScriptableObject(kStringType)
|
|
#endif // DEBUGGER
|
|
{
|
|
AvmAssert(len >= 0);
|
|
m_length = len;
|
|
MMGC_MEM_TYPE(this);
|
|
setBuf(allocBuf(m_length));
|
|
memcpy (getData(), str, m_length * sizeof(wchar));
|
|
getData()[m_length] = 0;
|
|
}
|
|
|
|
// concat
|
|
String::String(Stringp s1, Stringp s2)
|
|
#ifdef DEBUGGER
|
|
: AvmPlusScriptableObject(kStringType)
|
|
#endif // DEBUGGER
|
|
{
|
|
m_length = s1->length() + s2->length();
|
|
AvmAssert(m_length >= 0);
|
|
setPrefixOrOffsetOrNumber(uintptr(s1) | PREFIXFLAG);
|
|
if (s2->needsNormalization()) s2->normalize();
|
|
setBuf(s2->m_buf);
|
|
}
|
|
|
|
// substr
|
|
String::String(Stringp s, int pos, int len)
|
|
#ifdef DEBUGGER
|
|
: AvmPlusScriptableObject(kStringType)
|
|
#endif // DEBUGGER
|
|
{
|
|
// out-of-bounds requests return sensible things
|
|
if (pos < 0) {
|
|
pos = 0;
|
|
}
|
|
if (len < 0) {
|
|
len = 0;
|
|
}
|
|
|
|
int s_len = s->length();
|
|
if (pos + len > s_len) {
|
|
len = s_len - pos;
|
|
}
|
|
if (pos > s_len) {
|
|
len = 0;
|
|
}
|
|
|
|
AvmAssert(pos >= 0);
|
|
AvmAssert(len == 0 || pos + len <= s_len);
|
|
|
|
#if 0 // old way
|
|
if (s->hasPrefix()) s->normalize();
|
|
|
|
m_length = len;
|
|
GC* gc = GC::GetGC(this);
|
|
MMGC_MEM_TYPE(this);
|
|
m_buf = (wchar *) gc->Alloc (sizeof(wchar)*(m_length+1), 0);
|
|
memcpy (m_buf, s->m_buf+pos, m_length * sizeof(wchar));
|
|
m_buf[m_length] = 0;
|
|
m_prefixOrOffsetOrNumber = 0;
|
|
#endif
|
|
|
|
if (s->hasOffset())
|
|
{
|
|
m_length = len;
|
|
setBuf(s->m_buf);
|
|
m_prefixOrOffsetOrNumber = int(((s->getOffset() + pos) << 2) | OFFSETFLAG);
|
|
return;
|
|
}
|
|
else if (s->hasPrefix())
|
|
{
|
|
Stringp news = s;
|
|
while (news->getPrefix() && pos < news->getPrefix()->length())
|
|
news = news->getPrefix();
|
|
|
|
int newpos = pos;
|
|
int segmentLen = news->length();
|
|
if (news->getPrefix())
|
|
{
|
|
int prefixLen = news->getPrefix()->length();
|
|
newpos -= prefixLen;
|
|
segmentLen -= prefixLen;
|
|
}
|
|
|
|
// If our substring is completely contained within our prefix
|
|
// string, we can just use that string. Otherwise we need
|
|
// to normalize our string and generate an offset from the
|
|
// new string.
|
|
if ((newpos + len) <= segmentLen)
|
|
{
|
|
m_length = len;
|
|
setBuf(news->m_buf);
|
|
int offset = news->getOffset() + newpos;
|
|
m_prefixOrOffsetOrNumber = int((offset << 2) | OFFSETFLAG);
|
|
return;
|
|
}
|
|
|
|
s->normalize();
|
|
}
|
|
|
|
m_length = len;
|
|
setBuf(s->m_buf);
|
|
m_prefixOrOffsetOrNumber = int((pos << 2) | OFFSETFLAG);
|
|
}
|
|
|
|
// compare (dst,len) to (src,len), including nulls
|
|
int String::Compare(const wchar *dst, int dstLen, const wchar *src, int srcLen)
|
|
{
|
|
int ret = 0;
|
|
int count = (dstLen < srcLen) ? dstLen : srcLen; // choose smaller of two
|
|
const wchar *dstend = dst + count;
|
|
|
|
while(dst < dstend && 0 == (ret = (int)(*src - *dst)))
|
|
{
|
|
++src, ++dst;
|
|
}
|
|
|
|
// catch substring cases (e.g. '1' vs. '104')
|
|
if (ret == 0)
|
|
{
|
|
if (srcLen < dstLen)
|
|
ret = -1;
|
|
else if (srcLen > dstLen)
|
|
ret = 1;
|
|
else
|
|
; // really equal
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
// compare (dst,len) to (src), src is null-terminated 8bit string
|
|
int String::Compare(const wchar *dst, const char *src, int len)
|
|
{
|
|
int ret = 0;
|
|
const wchar *dstend = dst + len;
|
|
|
|
while(dst < dstend && *src && 0 == (ret = (int)(((wchar)*src) - *dst)) )
|
|
{
|
|
++src, ++dst;
|
|
}
|
|
|
|
if (ret == 0)
|
|
{
|
|
// catch substring cases (e.g. '1' vs. '104')
|
|
if (dst < dstend)
|
|
{
|
|
// more chars in dst than src
|
|
AvmAssert(*src == 0);
|
|
ret = -1;
|
|
}
|
|
else if (*src)
|
|
{
|
|
// more chars in src than dst
|
|
AvmAssert(dst == dstend);
|
|
ret = 1;
|
|
}
|
|
else
|
|
{
|
|
// really equal
|
|
AvmAssert(dst == dstend);
|
|
AvmAssert(*src == 0);
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
bool String::Contains(wchar c)
|
|
{
|
|
if (hasPrefix()) normalize();
|
|
|
|
const wchar *p = getData() + getOffset();
|
|
|
|
while (*p && (*p != c)) {
|
|
p++;
|
|
}
|
|
|
|
return (*p == c);
|
|
}
|
|
|
|
|
|
// flatten a composite string
|
|
void String::normalize()
|
|
{
|
|
AvmAssert(needsNormalization() == true);
|
|
MMGC_MEM_TYPE(this);
|
|
StringBuf *newData = allocBuf(length());
|
|
if (newData == NULL)
|
|
return;
|
|
wchar *new_buf = newData->m_buf;
|
|
new_buf[length()] = 0;
|
|
|
|
if (hasPrefix())
|
|
{
|
|
// copy suffix strings right to left
|
|
Stringp p = this;
|
|
for (; p->getPrefix() != 0; p = p->getPrefix())
|
|
{
|
|
memcpy(new_buf + p->getPrefix()->length(), p->getData(), sizeof(wchar)*(p->length()-p->getPrefix()->length()));
|
|
}
|
|
|
|
memcpy(new_buf, p->getData() + p->getOffset(), sizeof(wchar) * p->length());
|
|
setBuf(newData);
|
|
}
|
|
else
|
|
{
|
|
AvmAssert(hasOffset());
|
|
memcpy(new_buf, getData() + getOffset(), sizeof(wchar) * length());
|
|
setBuf(newData);
|
|
}
|
|
|
|
// prefix is left for GC to dispose of
|
|
setPrefixOrOffsetOrNumber(0);
|
|
}
|
|
|
|
// encode utf8
|
|
UTF8String* String::toUTF8String()
|
|
{
|
|
if (hasPrefix()) normalize();
|
|
int utf8len = UnicodeUtils::Utf16ToUtf8(getData() + getOffset(), length(), NULL, 0);
|
|
|
|
if( utf8len < 0 )
|
|
{
|
|
utf8len = 0;
|
|
}
|
|
|
|
UTF8String* out = new (GC::GetGC(this), utf8len) UTF8String(utf8len);
|
|
|
|
if (out) {
|
|
char *dst = out->lockBuffer();
|
|
UnicodeUtils::Utf16ToUtf8(getData() + getOffset(), length(), (uint8*)dst, utf8len);
|
|
dst[utf8len] = 0;
|
|
out->unlockBuffer();
|
|
}
|
|
return out;
|
|
}
|
|
|
|
//
|
|
// uppercase/lowercase conversion
|
|
//
|
|
|
|
const wchar String::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
|
|
};
|
|
|
|
const wchar String::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
|
|
};
|
|
|
|
// 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*/ wchar String::wCharToUpper (wchar ch)
|
|
{
|
|
AvmAssert (sizeof (lowerCaseBase) == sizeof (upperCaseConversion));
|
|
|
|
wchar result = ch;
|
|
// Do a binary search in lowerCaseBase for wchar
|
|
int lo = 0;
|
|
int hi = (sizeof (lowerCaseBase) / sizeof (lowerCaseBase[0])) - 1;
|
|
|
|
while (lo <= hi)
|
|
{
|
|
int pivot = (lo+hi)>>1;
|
|
int 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;
|
|
}
|
|
|
|
// 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.
|
|
|
|
const unsigned char String::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-64
|
|
0x00, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, //65-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-224
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //225-239
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 //240-255
|
|
};
|
|
|
|
const unsigned char String::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-64
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //65-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, 0x20, //208-224
|
|
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, //225-239
|
|
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 //240-255
|
|
};
|
|
|
|
const wchar String::upperCaseBase[] = {
|
|
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, 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, 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
|
|
};
|
|
|
|
const wchar String::lowerCaseConversion[] = {
|
|
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, 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, 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*/ wchar String::wCharToLower(wchar ch)
|
|
{
|
|
AvmAssert (sizeof (upperCaseBase) == sizeof (lowerCaseConversion));
|
|
|
|
wchar result = ch;
|
|
// Do a binary search in upperCaseBase for wchar
|
|
int lo = 0;
|
|
int hi = (sizeof (upperCaseBase) / sizeof (upperCaseBase[0])) - 1;
|
|
|
|
while (lo <= hi)
|
|
{
|
|
int pivot = (lo+hi)>>1;
|
|
int 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()
|
|
{
|
|
GC* gc = GC::GetGC(this);
|
|
int len = length();
|
|
Stringp out = new (gc) String(len);
|
|
|
|
// Flag to detect whether any changes were made
|
|
bool changed = false;
|
|
|
|
// First, try quick conversion for low ASCII characters.
|
|
wchar *dst = out->lockBuffer();
|
|
const wchar *src = c_str();
|
|
const wchar *end = src + len;
|
|
wchar charIn, charOut;
|
|
while (src < end)
|
|
{
|
|
charIn = *src;
|
|
if (charIn >= 0xFF)
|
|
break;
|
|
|
|
charOut = String::toupper_map[charIn] ^ charIn;
|
|
if (charOut != charIn)
|
|
changed = true;
|
|
|
|
*dst++ = charOut;
|
|
src++;
|
|
}
|
|
|
|
// If that didn't work, resume from where we left off
|
|
// with slow full Unicode conversion.
|
|
while (src < end)
|
|
{
|
|
charIn = *src;
|
|
charOut = wCharToUpper(charIn);
|
|
if (charOut != charIn)
|
|
changed = true;
|
|
|
|
*dst++ = charOut;
|
|
src++;
|
|
}
|
|
|
|
*dst = 0;
|
|
out->unlockBuffer();
|
|
|
|
// Return new string. If nothing changed, return old
|
|
// string (the new string will be GC'd)
|
|
return changed ? out : this;
|
|
}
|
|
|
|
Stringp String::toLowerCase()
|
|
{
|
|
GC* gc = GC::GetGC(this);
|
|
int len = length();
|
|
Stringp out = new (gc) String(len);
|
|
|
|
// Flag to detect whether any changes were made
|
|
bool changed = false;
|
|
|
|
// First, try quick conversion for low ASCII characters.
|
|
wchar *dst = out->lockBuffer();
|
|
const wchar *src = c_str();
|
|
const wchar *end = src + len;
|
|
wchar charIn, charOut;
|
|
while (src < end)
|
|
{
|
|
charIn = *src;
|
|
if (charIn >= 0xFF)
|
|
break;
|
|
|
|
charOut = String::tolower_map[charIn] ^ charIn;
|
|
if (charOut != charIn)
|
|
changed = true;
|
|
|
|
*dst++ = charOut;
|
|
src++;
|
|
}
|
|
|
|
// If that didn't work, resume from where we left off
|
|
// with slow full Unicode conversion.
|
|
while (src < end)
|
|
{
|
|
charIn = *src;
|
|
charOut = wCharToLower(charIn);
|
|
if (charOut != charIn)
|
|
changed = true;
|
|
|
|
*dst++ = charOut;
|
|
src++;
|
|
}
|
|
|
|
*dst = 0;
|
|
out->unlockBuffer();
|
|
|
|
// Return new string. If nothing changed, return old
|
|
// string (the new string will be GC'd)
|
|
return changed ? out : this;
|
|
}
|
|
|
|
int String::indexOf(Stringp substr, int iStartPos)
|
|
{
|
|
if(!substr)
|
|
return -1;
|
|
|
|
int sublen = substr->length();
|
|
if (iStartPos > this->length())
|
|
iStartPos = this->length();
|
|
|
|
// iRight 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 int iRight = this->length() - sublen;
|
|
|
|
// 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 (argv[1] > iRight), then we never enter the loop
|
|
if (iStartPos < 0) {
|
|
iStartPos = 0;
|
|
}
|
|
|
|
// our substr to find is only one character
|
|
if (sublen == 1)
|
|
{
|
|
const wchar substrchar = substr->c_str()[0];
|
|
const wchar *selfstr = this->c_str();
|
|
for ( ; iStartPos <= iRight; iStartPos++)
|
|
{
|
|
if (substrchar == selfstr[iStartPos])
|
|
{
|
|
return iStartPos;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
const wchar *substrstr = substr->c_str();
|
|
const wchar *selfstr = this->c_str();
|
|
selfstr += iStartPos;
|
|
for ( ; iStartPos <= iRight; iStartPos++)
|
|
{
|
|
int j;
|
|
for (j = 0; j < sublen; j++)
|
|
{
|
|
if (substrstr[j] != selfstr[j])
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (j == sublen)
|
|
{
|
|
return iStartPos;
|
|
}
|
|
selfstr++;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
int String::indexOfDouble(Stringp substr, double dStartPos)
|
|
{
|
|
dStartPos = MathUtils::toInt(dStartPos);
|
|
int iStartPos = (dStartPos > (double)this->length() ? this->length() : (int)dStartPos);
|
|
return indexOf (substr, iStartPos);
|
|
}
|
|
|
|
Stringp String::charAt(int iPos)
|
|
{
|
|
GC *gc = GC::GetGC(this);
|
|
AvmCore *core = (AvmCore *) gc->GetGCContextVariable (MMgc::GC::GCV_AVMCORE);
|
|
if (iPos >= 0 && iPos < length())
|
|
{
|
|
wchar ch = !this->needsNormalization() ? getData()[iPos] : ((*this)[iPos]);
|
|
if (ch < 128)
|
|
{
|
|
return core->cachedChars[ch];
|
|
}
|
|
else
|
|
{
|
|
return new (gc) String(this, iPos, 1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return core->kEmptyString;
|
|
}
|
|
}
|
|
|
|
Stringp String::charAtDouble(double dPos)
|
|
{
|
|
dPos = MathUtils::toInt(dPos);
|
|
int iPos = (dPos > (double)this->length()) ? this->length() : (int)dPos;
|
|
return charAt (iPos);
|
|
}
|
|
|
|
double String::charCodeAt(int iPos)
|
|
{
|
|
if (iPos >= 0 && iPos < length())
|
|
return (*this)[iPos];
|
|
else
|
|
return MathUtils::nan();
|
|
}
|
|
|
|
double String::charCodeAtDouble(double dPos)
|
|
{
|
|
dPos = MathUtils::toInt(dPos);
|
|
int iPos = (dPos > (double)this->length()) ? this->length() : (int)dPos;
|
|
return charCodeAt (iPos);
|
|
}
|
|
|
|
wchar String::operator[] (int index)
|
|
{
|
|
AvmAssert(index >=0 && index < length());
|
|
if (!hasPrefix())
|
|
{
|
|
return getData()[index + getOffset()];
|
|
}
|
|
else
|
|
{
|
|
AvmAssert (hasPrefix());
|
|
normalize();
|
|
return getData()[index];
|
|
|
|
#if 0 // This is the code if we want to skip the normalizations
|
|
// if this is a composite string, find the prefix containing iPos
|
|
Stringp s = this;
|
|
while (s->getPrefix() && index < s->getPrefix()->length())
|
|
s = s->getPrefix();
|
|
|
|
if (s->getPrefix())
|
|
index -= s->getPrefix()->length();
|
|
return s->getData()[s->getOffset() + index];
|
|
#endif
|
|
}
|
|
}
|
|
|
|
bool String::isWhitespace()
|
|
{
|
|
Stringp s = this;
|
|
do
|
|
{
|
|
int base = !s->getPrefix() ? 0 : s->getPrefix()->length();
|
|
for (int i = s->length()-base-1; i >= 0; i--)
|
|
if (!isSpace(s->getData()[s->getOffset() + i]))
|
|
return false;
|
|
}
|
|
while ( (s = s->getPrefix()) != 0);
|
|
return true;
|
|
}
|
|
|
|
int String::lastIndexOf(Stringp substr, int iStartPos)
|
|
{
|
|
int sublen = substr->length();
|
|
iStartPos = (iStartPos > this->length()) ? this->length() : iStartPos;
|
|
|
|
// iRight 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 int iRight = this->length() - sublen;
|
|
|
|
// bug 78346: argv[1] might be greater than iRight
|
|
// (similar reasons to above apply).
|
|
if (iStartPos > iRight) {
|
|
iStartPos = iRight;
|
|
}
|
|
const wchar *substrstr = substr->c_str();
|
|
const wchar *selfstr = this->c_str() + iStartPos;
|
|
for ( ; iStartPos >= 0 ; iStartPos-- )
|
|
{
|
|
int j;
|
|
for (j = 0; j < sublen; j++)
|
|
{
|
|
if (substrstr[j] != selfstr[j])
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (j == sublen)
|
|
{
|
|
return iStartPos;
|
|
}
|
|
selfstr--;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
int String::lastIndexOfDouble(Stringp substr, double dStartPos)
|
|
{
|
|
if (!MathUtils::isNaN(dStartPos))
|
|
dStartPos = MathUtils::toInt(dStartPos);
|
|
else
|
|
dStartPos = this->length();
|
|
int iStartPos = (dStartPos > this->length() ? this->length() : (int)dStartPos);
|
|
return lastIndexOf (substr, iStartPos);
|
|
}
|
|
|
|
int String::localeCompare(Stringp other, Atom* /*argv*/, int /*argc*/)
|
|
{
|
|
if ( !other )
|
|
{
|
|
GC *gc = GC::GetGC(this);
|
|
AvmCore *core = (AvmCore *) gc->GetGCContextVariable (MMgc::GC::GCV_AVMCORE);
|
|
other = core->knull;
|
|
}
|
|
|
|
return other->Compare(*this);
|
|
}
|
|
|
|
void String::generateIntegerEquivalent (AvmCore* core)
|
|
{
|
|
AvmAssert(this->isInterned());
|
|
AvmAssert(!this->hasOffset());
|
|
AvmAssert(!this->hasPrefix());
|
|
uint32 index;
|
|
(void)core;
|
|
if (core->getIndexFromString (this, &index))
|
|
{
|
|
if (!(index & ScriptObject::MAX_INTEGER_MASK))
|
|
{
|
|
m_prefixOrOffsetOrNumber = index<<3 | NUMBERFLAG;
|
|
}
|
|
}
|
|
}
|
|
|
|
String::StringBuf *String::allocBuf(int numChars)
|
|
{
|
|
GC* gc = GC::GetGC(this);
|
|
return new (gc, sizeof(wchar)*(numChars+1)) StringBuf();
|
|
}
|
|
|
|
Stringp String::substring(int start, int end)
|
|
{
|
|
GC *gc = GC::GetGC(this);
|
|
NativeObjectHelpers::ClampBInt(start, end, this->length());
|
|
return new (gc) String(this, start, (end-start));
|
|
}
|
|
|
|
Stringp String::substringDouble(double d_start, double d_end)
|
|
{
|
|
GC *gc = GC::GetGC(this);
|
|
double start = MathUtils::toInt(d_start);
|
|
double end = MathUtils::toInt(d_end);
|
|
NativeObjectHelpers::ClampB(start, end, length());
|
|
return new (gc) String(this, (int)start, (int)(end-start));
|
|
}
|
|
|
|
Stringp String::slice(int start, int end)
|
|
{
|
|
GC *gc = GC::GetGC(this);
|
|
int len = this->length();
|
|
start = (int)NativeObjectHelpers::ClampIndexInt(start, len);
|
|
end = (int)NativeObjectHelpers::ClampIndexInt(end, len);
|
|
if (end < start)
|
|
end = start;
|
|
|
|
return new (gc) String(this, start, end-start);
|
|
}
|
|
|
|
Stringp String::sliceDouble(double d_start, double d_end)
|
|
{
|
|
GC *gc = GC::GetGC(this);
|
|
int len = this->length();
|
|
int start = (int)NativeObjectHelpers::ClampIndex(MathUtils::toInt(d_start), len);
|
|
int end = (int)NativeObjectHelpers::ClampIndex(MathUtils::toInt(d_end), len);
|
|
if (end < start)
|
|
end = start;
|
|
|
|
return new (gc) String(this, start, end-start);
|
|
}
|
|
|
|
Stringp String::substr(int start, int end)
|
|
{
|
|
GC *gc = GC::GetGC(this);
|
|
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?
|
|
if (end == 0x7ffffff)
|
|
{
|
|
end = len;
|
|
}
|
|
else if ((end > 0xffffff) || (start > 0xffffff)) // might overflow - use doubles
|
|
{
|
|
end = (int)NativeObjectHelpers::ClampIndex(double(end) + double(start), len);
|
|
}
|
|
else
|
|
{
|
|
end = (int)NativeObjectHelpers::ClampIndexInt(end + start, len);
|
|
}
|
|
|
|
if (end < start)
|
|
end = start;
|
|
|
|
return new (gc) String(this, start, end-start);
|
|
}
|
|
|
|
Stringp String::substrDouble(double d_start, double d_end)
|
|
{
|
|
GC *gc = GC::GetGC(this);
|
|
int len = this->length();
|
|
int start = (int)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...
|
|
int end = (int)NativeObjectHelpers::ClampIndex(MathUtils::toInt(d_end) + (double)start, len);
|
|
if (end < start)
|
|
end = start;
|
|
|
|
return new (gc) String(this, start, end-start);
|
|
}
|
|
|
|
void String::setPrefixOrOffsetOrNumber(uintptr value)
|
|
{
|
|
#ifdef MMGC_DRC
|
|
// first decrement existing prefix
|
|
if((m_prefixOrOffsetOrNumber & STRINGFLAGS) == PREFIXFLAG)
|
|
getPrefix()->DecrementRef();
|
|
#endif
|
|
GC::GetGC(this)->WriteBarrierNoSubstitute(this, (void*)value);
|
|
m_prefixOrOffsetOrNumber = value;
|
|
#ifdef MMGC_DRC
|
|
if((value & STRINGFLAGS) == PREFIXFLAG)
|
|
getPrefix()->IncrementRef();
|
|
#endif
|
|
}
|
|
|
|
#ifdef DEBUGGER
|
|
uint32 String::size() const
|
|
{
|
|
uint32 bufSize = sizeof(StringBuf) + length() * sizeof(wchar);
|
|
uint32 size = sizeof(String) - sizeof(AvmPlusScriptableObject) + bufSize / m_buf->RefCount();
|
|
if(getPrefix())
|
|
{
|
|
// - sizeof(String) so we don't recursively count it
|
|
size += (getPrefix()->size() - sizeof(String));
|
|
}
|
|
return size;
|
|
}
|
|
|
|
Stringp String::getTypeName() const
|
|
{
|
|
AvmCore *core = this->core();
|
|
|
|
if (core->callStack && core->callStack->env)
|
|
{
|
|
Toplevel *toplevel = core->callStack->env->toplevel();
|
|
ClassClosure *clazz = toplevel->stringClass;
|
|
|
|
if (clazz)
|
|
{
|
|
return clazz->format(core);
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
#endif
|
|
}
|