Beispiel #1
0
            private StringBuilder InternalDecompose(ArrayList char_lengths)
            {
                StringBuilder target = new StringBuilder();
                StringBuilder buffer = new StringBuilder();

                _hasArabic = false;
                _hasNSMs   = false;

                for (int i = 0; i < _text.Length; ++i)
                {
                    BidiCharacterType ct = UnicodeCharacterDataResolver.GetBidiCharacterType(_text[i]);
                    _hasArabic |= ((ct == BidiCharacterType.AL) || (ct == BidiCharacterType.AN));
                    _hasNSMs   |= (ct == BidiCharacterType.NSM);

                    buffer.Length = 0;
                    GetRecursiveDecomposition(false, _text[i], buffer);
                    char_lengths.Add(1 - buffer.Length);
                    // add all of the characters in the decomposition.
                    // (may be just the original character, if there was
                    // no decomposition mapping)

                    char ch;
                    for (int j = 0; j < buffer.Length; ++j)
                    {
                        ch = buffer[j];
                        UnicodeCanonicalClass chClass = UnicodeCharacterDataResolver.GetUnicodeCanonicalClass(ch);
                        int k = target.Length; // insertion point
                        if (chClass != UnicodeCanonicalClass.NR)
                        {
                            // bubble-sort combining marks as necessary
                            char ch2;
                            for (; k > 0; --k)
                            {
                                ch2 = target[k - 1];
                                if (UnicodeCharacterDataResolver.GetUnicodeCanonicalClass(ch2) <= chClass)
                                {
                                    break;
                                }
                            }
                        }
                        target.Insert(k, ch);
                    }
                }
                return(target);
            }
Beispiel #2
0
            private void InternalCompose(StringBuilder target, ArrayList char_lengths)
            {
                if (target.Length == 0)
                {
                    return;
                }
                int  starterPos = 0;
                int  compPos    = 1;
                int  text_idx   = 0;
                char starterCh  = target[0];

                char_lengths[starterPos] = (int)char_lengths[starterPos] + 1;

                UnicodeCanonicalClass lastClass = UnicodeCharacterDataResolver.GetUnicodeCanonicalClass(starterCh);

                if (lastClass != UnicodeCanonicalClass.NR)
                {
                    lastClass = (UnicodeCanonicalClass)256; // fix for strings staring with a combining mark
                }
                int oldLen = target.Length;

                // Loop on the decomposed characters, combining where possible
                char ch;

                for (int decompPos = compPos; decompPos < target.Length; ++decompPos)
                {
                    ch = target[decompPos];
                    UnicodeCanonicalClass chClass = UnicodeCharacterDataResolver.GetUnicodeCanonicalClass(ch);
                    char composite = GetPairwiseComposition(starterCh, ch);
                    UnicodeDecompositionType composeType = UnicodeCharacterDataResolver.GetUnicodeDecompositionType(composite);

                    if (composeType == UnicodeDecompositionType.None &&
                        composite != BidiChars.NotAChar &&
                        (lastClass < chClass || lastClass == UnicodeCanonicalClass.NR))
                    {
                        target[starterPos]       = composite;
                        char_lengths[starterPos] = (int)char_lengths[starterPos] + 1;
                        // we know that we will only be replacing non-supplementaries by non-supplementaries
                        // so we don't have to adjust the decompPos
                        starterCh = composite;
                    }
                    else
                    {
                        if (chClass == UnicodeCanonicalClass.NR)
                        {
                            starterPos = compPos;
                            starterCh  = ch;
                            text_idx++;
                        }
                        lastClass       = chClass;
                        target[compPos] = ch;
                        //char_lengths[compPos] = (int)char_lengths[compPos] + 1;
                        int chkPos = compPos;
                        if ((int)char_lengths[chkPos] < 0)
                        {
                            while ((int)char_lengths[chkPos] < 0)
                            {
                                char_lengths[chkPos] = (int)char_lengths[chkPos] + 1;
                                char_lengths.Insert(compPos, 0);
                                chkPos++;
                            }
                        }
                        else
                        {
                            char_lengths[chkPos] = (int)char_lengths[chkPos] + 1;
                        }

                        if (target.Length != oldLen) // MAY HAVE TO ADJUST!
                        {
                            decompPos += target.Length - oldLen;
                            oldLen     = target.Length;
                        }
                        ++compPos;
                    }
                }
                target.Length = compPos;
                char_lengths.RemoveRange(compPos, char_lengths.Count - compPos);
            }