The Tor Browser / file revision

 /*

 **********************************************************************

 *   Copyright (C) 1999-2009, International Business Machines

 *   Corporation and others.  All Rights Reserved.

 **********************************************************************

 *

 * File USC_IMPL.C

 *

 * Modification History:

 *

 *   Date        Name        Description

 *   07/08/2002  Eric Mader  Creation.

 ******************************************************************************

 */

 #include "unicode/uscript.h"

 #include "usc_impl.h"

 #include "cmemory.h"

 #define ARRAY_SIZE(array) (sizeof array  / sizeof array[0])

 #define PAREN_STACK_DEPTH 32

 #define MOD(sp) ((sp) % PAREN_STACK_DEPTH)

 #define LIMIT_INC(sp) (((sp) < PAREN_STACK_DEPTH)? (sp) + 1 : PAREN_STACK_DEPTH)

 #define INC(sp,count) (MOD((sp) + (count)))

 #define INC1(sp) (INC(sp, 1))

 #define DEC(sp,count) (MOD((sp) + PAREN_STACK_DEPTH - (count)))

 #define DEC1(sp) (DEC(sp, 1))

 #define STACK_IS_EMPTY(scriptRun) ((scriptRun)->pushCount <= 0)

 #define STACK_IS_NOT_EMPTY(scriptRun) (! STACK_IS_EMPTY(scriptRun))

 #define TOP(scriptRun) ((scriptRun)->parenStack[(scriptRun)->parenSP])

 #define SYNC_FIXUP(scriptRun) ((scriptRun)->fixupCount = 0)

 struct ParenStackEntry

 {

     int32_t pairIndex;

     UScriptCode scriptCode;

 };

 struct UScriptRun

 {

     int32_t textLength;

     const UChar *textArray;

     int32_t scriptStart;

     int32_t scriptLimit;

     UScriptCode scriptCode;

     struct ParenStackEntry parenStack[PAREN_STACK_DEPTH];

     int32_t parenSP;

     int32_t pushCount;

     int32_t fixupCount;

 };

 static int8_t highBit(int32_t value);

 static const UChar32 pairedChars[] = {

     0x0028, 0x0029, /* ascii paired punctuation */

     0x003c, 0x003e,

     0x005b, 0x005d,

     0x007b, 0x007d,

     0x00ab, 0x00bb, /* guillemets */

     0x2018, 0x2019, /* general punctuation */

     0x201c, 0x201d,

     0x2039, 0x203a,

     0x3008, 0x3009, /* chinese paired punctuation */

     0x300a, 0x300b,

     0x300c, 0x300d,

     0x300e, 0x300f,

     0x3010, 0x3011,

     0x3014, 0x3015,

     0x3016, 0x3017,

     0x3018, 0x3019,

     0x301a, 0x301b

 };

 static void push(UScriptRun *scriptRun, int32_t pairIndex, UScriptCode scriptCode)

 {

     scriptRun->pushCount  = LIMIT_INC(scriptRun->pushCount);

     scriptRun->fixupCount = LIMIT_INC(scriptRun->fixupCount);

     scriptRun->parenSP = INC1(scriptRun->parenSP);

     scriptRun->parenStack[scriptRun->parenSP].pairIndex  = pairIndex;

     scriptRun->parenStack[scriptRun->parenSP].scriptCode = scriptCode;

 }

 static void pop(UScriptRun *scriptRun)

 {

     if (STACK_IS_EMPTY(scriptRun)) {

         return;

     }

     if (scriptRun->fixupCount > 0) {

         scriptRun->fixupCount -= 1;

     }

     scriptRun->pushCount -= 1;

     scriptRun->parenSP = DEC1(scriptRun->parenSP);

     /* If the stack is now empty, reset the stack

        pointers to their initial values.

      */

     if (STACK_IS_EMPTY(scriptRun)) {

         scriptRun->parenSP = -1;

     }

 }

 static void fixup(UScriptRun *scriptRun, UScriptCode scriptCode)

 {

     int32_t fixupSP = DEC(scriptRun->parenSP, scriptRun->fixupCount);

     while (scriptRun->fixupCount-- > 0) {

         fixupSP = INC1(fixupSP);

         scriptRun->parenStack[fixupSP].scriptCode = scriptCode;

     }

 }

 static int8_t

 highBit(int32_t value)

 {

     int8_t bit = 0;

     if (value <= 0) {

         return -32;

     }

     if (value >= 1 << 16) {

         value >>= 16;

         bit += 16;

     }

     if (value >= 1 << 8) {

         value >>= 8;

         bit += 8;

     }

     if (value >= 1 << 4) {

         value >>= 4;

         bit += 4;

     }

     if (value >= 1 << 2) {

         value >>= 2;

         bit += 2;

     }

     if (value >= 1 << 1) {

         value >>= 1;

         bit += 1;

     }

     return bit;

 }

 static int32_t

 getPairIndex(UChar32 ch)

 {

     int32_t pairedCharCount = ARRAY_SIZE(pairedChars);

     int32_t pairedCharPower = 1 << highBit(pairedCharCount);

     int32_t pairedCharExtra = pairedCharCount - pairedCharPower;

     int32_t probe = pairedCharPower;

     int32_t pairIndex = 0;

     if (ch >= pairedChars[pairedCharExtra]) {

         pairIndex = pairedCharExtra;

     }

     while (probe > (1 << 0)) {

         probe >>= 1;

         if (ch >= pairedChars[pairIndex + probe]) {

             pairIndex += probe;

         }

     }

     if (pairedChars[pairIndex] != ch) {

         pairIndex = -1;

     }

     return pairIndex;

 }

 static UBool

 sameScript(UScriptCode scriptOne, UScriptCode scriptTwo)

 {

     return scriptOne <= USCRIPT_INHERITED || scriptTwo <= USCRIPT_INHERITED || scriptOne == scriptTwo;

 }

 U_CAPI UScriptRun * U_EXPORT2

 uscript_openRun(const UChar *src, int32_t length, UErrorCode *pErrorCode)

 {

     UScriptRun *result = NULL;

     if (pErrorCode == NULL || U_FAILURE(*pErrorCode)) {

         return NULL;

     }

     result = uprv_malloc(sizeof (UScriptRun));

     if (result == NULL) {

         *pErrorCode = U_MEMORY_ALLOCATION_ERROR;

         return NULL;

     }

     uscript_setRunText(result, src, length, pErrorCode);

     /* Release the UScriptRun if uscript_setRunText() returns an error */

     if (U_FAILURE(*pErrorCode)) {

         uprv_free(result);

         result = NULL;

     }

     return result;

 }

 U_CAPI void U_EXPORT2

 uscript_closeRun(UScriptRun *scriptRun)

 {

     if (scriptRun != NULL) {

         uprv_free(scriptRun);

     }

 }

 U_CAPI void U_EXPORT2

 uscript_resetRun(UScriptRun *scriptRun)

 {

     if (scriptRun != NULL) {

         scriptRun->scriptStart = 0;

         scriptRun->scriptLimit = 0;

         scriptRun->scriptCode  = USCRIPT_INVALID_CODE;

         scriptRun->parenSP     = -1;

         scriptRun->pushCount   =  0;

         scriptRun->fixupCount  =  0;

     }

 }

 U_CAPI void U_EXPORT2

 uscript_setRunText(UScriptRun *scriptRun, const UChar *src, int32_t length, UErrorCode *pErrorCode)

 {

     if (pErrorCode == NULL || U_FAILURE(*pErrorCode)) {

         return;

     }

     if (scriptRun == NULL || length < 0 || ((src == NULL) != (length == 0))) {

         *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;

         return;

     }

     scriptRun->textArray  = src;

     scriptRun->textLength = length;

     uscript_resetRun(scriptRun);

 }

 U_CAPI UBool U_EXPORT2

 uscript_nextRun(UScriptRun *scriptRun, int32_t *pRunStart, int32_t *pRunLimit, UScriptCode *pRunScript)

 {

     UErrorCode error = U_ZERO_ERROR;

     /* if we've fallen off the end of the text, we're done */

     if (scriptRun == NULL || scriptRun->scriptLimit >= scriptRun->textLength) {

         return FALSE;

     }

     SYNC_FIXUP(scriptRun);

     scriptRun->scriptCode = USCRIPT_COMMON;

     for (scriptRun->scriptStart = scriptRun->scriptLimit; scriptRun->scriptLimit < scriptRun->textLength; scriptRun->scriptLimit += 1) {

         UChar   high = scriptRun->textArray[scriptRun->scriptLimit];

         UChar32 ch   = high;

         UScriptCode sc;

         int32_t pairIndex;

         /*

          * if the character is a high surrogate and it's not the last one

          * in the text, see if it's followed by a low surrogate

          */

         if (high >= 0xD800 && high <= 0xDBFF && scriptRun->scriptLimit < scriptRun->textLength - 1) {

             UChar low = scriptRun->textArray[scriptRun->scriptLimit + 1];

             /*

              * if it is followed by a low surrogate,

              * consume it and form the full character

              */

             if (low >= 0xDC00 && low <= 0xDFFF) {

                 ch = (high - 0xD800) * 0x0400 + low - 0xDC00 + 0x10000;

                 scriptRun->scriptLimit += 1;

             }

         }

         sc = uscript_getScript(ch, &error);

         pairIndex = getPairIndex(ch);

         /*

          * Paired character handling:

          *

          * if it's an open character, push it onto the stack.

          * if it's a close character, find the matching open on the

          * stack, and use that script code. Any non-matching open

          * characters above it on the stack will be poped.

          */

         if (pairIndex >= 0) {

             if ((pairIndex & 1) == 0) {

                 push(scriptRun, pairIndex, scriptRun->scriptCode);

             } else {

                 int32_t pi = pairIndex & ~1;

                 while (STACK_IS_NOT_EMPTY(scriptRun) && TOP(scriptRun).pairIndex != pi) {

                     pop(scriptRun);

                 }

                 if (STACK_IS_NOT_EMPTY(scriptRun)) {

                     sc = TOP(scriptRun).scriptCode;

                 }

             }

         }

         if (sameScript(scriptRun->scriptCode, sc)) {

             if (scriptRun->scriptCode <= USCRIPT_INHERITED && sc > USCRIPT_INHERITED) {

                 scriptRun->scriptCode = sc;

                 fixup(scriptRun, scriptRun->scriptCode);

             }

             /*

              * if this character is a close paired character,

              * pop the matching open character from the stack

              */

             if (pairIndex >= 0 && (pairIndex & 1) != 0) {

                 pop(scriptRun);

             }

         } else {

             /*

              * if the run broke on a surrogate pair,

              * end it before the high surrogate

              */

             if (ch >= 0x10000) {

                 scriptRun->scriptLimit -= 1;

             }

             break;

         }

     }

     if (pRunStart != NULL) {

         *pRunStart = scriptRun->scriptStart;

     }

     if (pRunLimit != NULL) {

         *pRunLimit = scriptRun->scriptLimit;

     }

     if (pRunScript != NULL) {

         *pRunScript = scriptRun->scriptCode;

     }

     return TRUE;

 }