StringObject.cpp

Go to the documentation of this file.

/* ***** 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) 2004-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);
    }

    const wchar* String::c_str() 
    {
        // For offset too since our string needs to be null terminated
        if (needsNormalization()) normalize();
        return getData(); 
    }

    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
        }
    }

    wchar* String::lockBuffer() 
    {
        // For offset too since our string needs to be null terminated
        if (needsNormalization()) normalize();
        return (wchar*) getData(); 
    }

    /*static*/ bool String::isSpace(wchar ch)
    {
        return (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r');
    }

    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;
        }

        if (sublen == 0)
            return iStartPos;

        const wchar *substrstr = substr->c_str();
        const wchar *selfstr = this->c_str() + iStartPos;
        for ( ; iStartPos >= 0 ; iStartPos-- )
        {
            for (int j = 0; j < sublen; j++)
            {
                if (substrstr[j] != selfstr[j])
                {
                    break;
                }

                if (j == (sublen - 1))
                    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)
    {  
        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
    uint64 String::size() const
    {
        uint64 size = sizeof(String) - sizeof(AvmPlusScriptableObject);
        uint64 bufSize = sizeof(StringBuf) + length() * sizeof(wchar);
        if(m_buf->RefCount() != 0)
            size += bufSize / m_buf->RefCount();
        else
            size += bufSize;
        return size;
    }
#endif

    StringNullTerminatedUTF8::StringNullTerminatedUTF8(MMgc::GC *gc, Stringp str) :
        m_str(str),
        m_bufptr(NULL),
        gc(gc)
    {
        MMGC_MEM_TYPE("StringNullTerminatedUTF8");
        int len = str->length();
        m_bufptr = (char*)gc->Alloc(len + 1);
       const wchar *data = str->c_str();
        for (int i=0; i < len; i++) {
            m_bufptr[i] = (char) data[i];
        }
        m_bufptr[len] = 0;
    }

    StringNullTerminatedUTF8::~StringNullTerminatedUTF8()
    {
        gc->Free(m_bufptr);
        m_str = NULL;
        m_bufptr = NULL;
    }
}   

---