The Tor Browser: intl/icu/source/io/ufmt_cmn.c@6474c204b198 (annotated)

intl/icu/source/io/ufmt_cmn.c@6474c204b198 (annotated)

intl/icu/source/io/ufmt_cmn.c

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /*
 ******************************************************************************
 *
 *   Copyright (C) 1998-2006, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *
 ******************************************************************************
 *
 * File ufmt_cmn.c
 *
 * Modification History:
 *
 *   Date        Name        Description
 *   12/02/98    stephen     Creation.
 *   03/12/99    stephen     Modified for new C API.
 *   03/15/99    stephen     Added defaultCPToUnicode, unicodeToDefaultCP
 *   07/19/99    stephen     Fixed bug in defaultCPToUnicode
 ******************************************************************************
 */
 #include "cstring.h"
 #include "cmemory.h"
 #include "ufmt_cmn.h"
 #include "unicode/uchar.h"
 #include "unicode/ucnv.h"
 #include "ustr_cnv.h"
 #define DIGIT_0     0x0030
 #define DIGIT_9     0x0039
 #define LOWERCASE_A 0x0061
 #define UPPERCASE_A 0x0041
 #define LOWERCASE_Z 0x007A
 #define UPPERCASE_Z 0x005A
 int
 ufmt_digitvalue(UChar c)
 {
     if( ((c>=DIGIT_0)&&(c<=DIGIT_9)) ||
         ((c>=LOWERCASE_A)&&(c<=LOWERCASE_Z)) ||
         ((c>=UPPERCASE_A)&&(c<=UPPERCASE_Z))  )
     {
       return c - DIGIT_0 - (c >= 0x0041 ? (c >= 0x0061 ? 39 : 7) : 0);
     }
     else
     {
       return -1;
     }
 }
 UBool
 ufmt_isdigit(UChar     c,
              int32_t     radix)
 {
     int digitVal = ufmt_digitvalue(c);
     return (UBool)(digitVal < radix && digitVal >= 0);
 }
 #define TO_UC_DIGIT(a) a <= 9 ? (DIGIT_0 + a) : (0x0037 + a)
 #define TO_LC_DIGIT(a) a <= 9 ? (DIGIT_0 + a) : (0x0057 + a)
 void
 ufmt_64tou(UChar     *buffer,
           int32_t   *len,
           uint64_t  value,
           uint8_t  radix,
           UBool     uselower,
           int32_t   minDigits)
 {
     int32_t  length = 0;
     uint32_t digit;
     UChar    *left, *right, temp;
     do {
         digit = (uint32_t)(value % radix);
         value = value / radix;
         buffer[length++] = (UChar)(uselower ? TO_LC_DIGIT(digit)
             : TO_UC_DIGIT(digit));
     } while(value);
     /* pad with zeroes to make it minDigits long */
     if(minDigits != -1 && length < minDigits) {
         while(length < minDigits && length < *len)
             buffer[length++] = DIGIT_0;  /*zero padding */
     }
     /* reverse the buffer */
     left     = buffer;
     right = buffer + length;
     while(left < --right) {
         temp     = *left;
         *left++     = *right;
         *right     = temp;
     }
     *len = length;
 }
 void
 ufmt_ptou(UChar    *buffer,
           int32_t   *len,
           void      *value,
           UBool     uselower)
 {
     int32_t i;
     int32_t length = 0;
     uint8_t *ptrIdx = (uint8_t *)&value;
 #if U_IS_BIG_ENDIAN
     for (i = 0; i < (int32_t)sizeof(void *); i++)
 #else
     for (i = (int32_t)sizeof(void *)-1; i >= 0 ; i--)
 #endif
     {
         uint8_t byteVal = ptrIdx[i];
         uint16_t firstNibble = (uint16_t)(byteVal>>4);
         uint16_t secondNibble = (uint16_t)(byteVal&0xF);
         if (uselower) {
             buffer[length++]=TO_LC_DIGIT(firstNibble);
             buffer[length++]=TO_LC_DIGIT(secondNibble);
         }
         else {
             buffer[length++]=TO_UC_DIGIT(firstNibble);
             buffer[length++]=TO_UC_DIGIT(secondNibble);
         }
     }
     *len = length;
 }
 int64_t
 ufmt_uto64(const UChar     *buffer,
           int32_t     *len,
           int8_t     radix)
 {
     const UChar     *limit;
     int32_t         count;
     int64_t        result;
     /* intialize parameters */
     limit     = buffer + *len;
     count     = 0;
     result    = 0;
     /* iterate through buffer */
     while(ufmt_isdigit(*buffer, radix) && buffer < limit) {
         /* read the next digit */
         result *= radix;
         result += ufmt_digitvalue(*buffer++);
         /* increment our count */
         ++count;
     }
     *len = count;
     return result;
 }
 #define NIBBLE_PER_BYTE 2
 void *
 ufmt_utop(const UChar     *buffer,
           int32_t     *len)
 {
     int32_t count, resultIdx, incVal, offset;
     /* This union allows the pointer to be written as an array. */
     union {
         void *ptr;
         uint8_t bytes[sizeof(void*)];
     } result;
     /* intialize variables */
     count      = 0;
     offset     = 0;
     result.ptr = NULL;
     /* Skip the leading zeros */
     while(buffer[count] == DIGIT_0 || u_isspace(buffer[count])) {
         count++;
         offset++;
     }
     /* iterate through buffer, stop when you hit the end */
     while(ufmt_isdigit(buffer[count], 16) && count < *len) {
         /* increment the count consumed */
         ++count;
     }
     /* detect overflow */
     if (count - offset > (int32_t)(sizeof(void*)*NIBBLE_PER_BYTE)) {
         offset = count - (int32_t)(sizeof(void*)*NIBBLE_PER_BYTE);
     }
     /* Initialize the direction of the input */
 #if U_IS_BIG_ENDIAN
     incVal = -1;
     resultIdx = (int32_t)(sizeof(void*) - 1);
 #else
     incVal = 1;
     resultIdx = 0;
 #endif
     /* Write how much was consumed. */
     *len = count;
     while(--count >= offset) {
         /* Get the first nibble of the byte */
         uint8_t byte = (uint8_t)ufmt_digitvalue(buffer[count]);
         if (count > offset) {
             /* Get the second nibble of the byte when available */
             byte = (uint8_t)(byte + (ufmt_digitvalue(buffer[--count]) << 4));
         }
         /* Write the byte into the array */
         result.bytes[resultIdx] = byte;
         resultIdx += incVal;
     }
     return result.ptr;
 }
 UChar*
 ufmt_defaultCPToUnicode(const char *s, int32_t sSize,
                         UChar *target, int32_t tSize)
 {
     UChar *alias;
     UErrorCode status = U_ZERO_ERROR;
     UConverter *defConverter = u_getDefaultConverter(&status);
     if(U_FAILURE(status) || defConverter == 0)
         return 0;
     if(sSize <= 0) {
         sSize = uprv_strlen(s) + 1;
     }
     /* perform the conversion in one swoop */
     if(target != 0) {
         alias = target;
         ucnv_toUnicode(defConverter, &alias, alias + tSize, &s, s + sSize - 1,
             NULL, TRUE, &status);
         /* add the null terminator */
         *alias = 0x0000;
     }
     u_releaseDefaultConverter(defConverter);
     return target;
 }

The Tor Browser / annotate

intl/icu/source/io/ufmt_cmn.c@6474c204b198 (annotated)

intl/icu/source/io/ufmt_cmn.c