The Tor Browser / file revision

 /*

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

 *

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

 }