The Tor Browser: intl/icu/source/common/usc_impl.c@b8a032363ba2 (annotated)

intl/icu/source/common/usc_impl.c@b8a032363ba2 (annotated)

intl/icu/source/common/usc_impl.c

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /*
 **********************************************************************
 *   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[] = {
 x0028, 0x0029, /* ascii paired punctuation */
 x003c, 0x003e,
 x005b, 0x005d,
 x007b, 0x007d,
 x00ab, 0x00bb, /* guillemets */
 x2018, 0x2019, /* general punctuation */
 x201c, 0x201d,
 x2039, 0x203a,
 x3008, 0x3009, /* chinese paired punctuation */
 x300a, 0x300b,
 x300c, 0x300d,
 x300e, 0x300f,
 x3010, 0x3011,
 x3014, 0x3015,
 x3016, 0x3017,
 x3018, 0x3019,
 x301a, 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;
 }

The Tor Browser / annotate

intl/icu/source/common/usc_impl.c@b8a032363ba2 (annotated)

intl/icu/source/common/usc_impl.c