The Tor Browser: intl/icu/source/tools/genrb/ustr.c@6474c204b198

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

     1 /*

     2 *******************************************************************************

3 *

     4 *   Copyright (C) 1998-2012, International Business Machines

     5 *   Corporation and others.  All Rights Reserved.

6 *

     7 *******************************************************************************

8 *

     9 * File ustr.c

    10 *

    11 * Modification History:

    12 *

    13 *   Date        Name        Description

    14 *   05/28/99    stephen     Creation.

    15 *******************************************************************************

    16 */

    18 #include "ustr.h"

    19 #include "cmemory.h"

    20 #include "cstring.h"

    21 #include "unicode/ustring.h"

    22 #include "unicode/putil.h"

    23 #include "unicode/utf16.h"

    25 /* Protos */

    26 static void ustr_resize(struct UString *s, int32_t len, UErrorCode *status);

    28 /* Macros */

    29 #define ALLOCATION(minSize) (minSize < 0x80 ? 0x80 : (2 * minSize + 0x80) & ~(0x80 - 1))

    31 U_CFUNC void

    32 ustr_init(struct UString *s)

    33 {

    34     s->fChars = 0;

    35     s->fLength = s->fCapacity = 0;

    36 }

    38 U_CFUNC void

    39 ustr_initChars(struct UString *s, const char* source, int32_t length, UErrorCode *status)

    40 {

    41     int i = 0;

    42     if (U_FAILURE(*status)) return;

    43     s->fChars = 0;

    44     s->fLength = s->fCapacity = 0;

    45     if (length == -1) {

    46         length = (int32_t)uprv_strlen(source);

    47     }

    48     if(s->fCapacity < length) {

    49       ustr_resize(s, ALLOCATION(length), status);

    50       if(U_FAILURE(*status)) return;

    51     }

    52     for (; i < length; i++)

    53     {

    54       UChar charToAppend;

    55       u_charsToUChars(source+i, &charToAppend, 1);

    56       ustr_ucat(s, charToAppend, status);

    57       /*

    58 #if U_CHARSET_FAMILY==U_ASCII_FAMILY

    59         ustr_ucat(s, (UChar)(uint8_t)(source[i]), status);

    60 #elif U_CHARSET_FAMILY==U_EBCDIC_FAMILY

    61         ustr_ucat(s, (UChar)asciiFromEbcdic[(uint8_t)(*cs++)], status);

    62 #else

    63 #   error U_CHARSET_FAMILY is not valid

    64 #endif

    65       */

    66     }

    67 }

    69 U_CFUNC void

    70 ustr_deinit(struct UString *s)

    71 {

    72     if (s) {

    73         uprv_free(s->fChars);

    74         s->fChars = 0;

    75         s->fLength = s->fCapacity = 0;

    76     }

    77 }

    79 U_CFUNC void

    80 ustr_cpy(struct UString *dst,

    81      const struct UString *src,

    82      UErrorCode *status)

    83 {

    84     if(U_FAILURE(*status) || dst == src)

    85         return;

    87     if(dst->fCapacity < src->fLength) {

    88         ustr_resize(dst, ALLOCATION(src->fLength), status);

    89         if(U_FAILURE(*status))

    90             return;

    91     }

    92     if(src->fChars == NULL || dst->fChars == NULL){

    93         return;

    94     }

    95     uprv_memcpy(dst->fChars, src->fChars, sizeof(UChar) * src->fLength);

    96     dst->fLength = src->fLength;

    97     dst->fChars[dst->fLength] = 0x0000;

    98 }

   100 U_CFUNC void

   101 ustr_setlen(struct UString *s,

   102         int32_t len,

   103         UErrorCode *status)

   104 {

   105     if(U_FAILURE(*status))

   106         return;

   108     if(s->fCapacity < (len + 1)) {

   109         ustr_resize(s, ALLOCATION(len), status);

   110         if(U_FAILURE(*status))

   111             return;

   112     }

   114     s->fLength = len;

   115     s->fChars[len] = 0x0000;

   116 }

   118 U_CFUNC void

   119 ustr_cat(struct UString *dst,

   120      const struct UString *src,

   121      UErrorCode *status)

   122 {

   123     ustr_ncat(dst, src, src->fLength, status);

   124 }

   126 U_CFUNC void

   127 ustr_ncat(struct UString *dst,

   128       const struct UString *src,

   129       int32_t n,

   130       UErrorCode *status)

   131 {

   132     if(U_FAILURE(*status) || dst == src)

   133         return;

   135     if(dst->fCapacity < (dst->fLength + n)) {

   136         ustr_resize(dst, ALLOCATION(dst->fLength + n), status);

   137         if(U_FAILURE(*status))

   138             return;

   139     }

   141     uprv_memcpy(dst->fChars + dst->fLength, src->fChars,

   142                 sizeof(UChar) * n);

   143     dst->fLength += src->fLength;

   144     dst->fChars[dst->fLength] = 0x0000;

   145 }

   147 U_CFUNC void

   148 ustr_ucat(struct UString *dst,

   149       UChar c,

   150       UErrorCode *status)

   151 {

   152     if(U_FAILURE(*status))

   153         return;

   155     if(dst->fCapacity < (dst->fLength + 1)) {

   156         ustr_resize(dst, ALLOCATION(dst->fLength + 1), status);

   157         if(U_FAILURE(*status))

   158             return;

   159     }

   161     uprv_memcpy(dst->fChars + dst->fLength, &c,

   162         sizeof(UChar) * 1);

   163     dst->fLength += 1;

   164     dst->fChars[dst->fLength] = 0x0000;

   165 }

   166 U_CFUNC void

   167 ustr_u32cat(struct UString *dst, UChar32 c, UErrorCode *status){

   168     if(c > 0x10FFFF){

   169         *status = U_ILLEGAL_CHAR_FOUND;

   170         return;

   171     }

   172     if(c >0xFFFF){

   173         ustr_ucat(dst, U16_LEAD(c), status);

   174         ustr_ucat(dst, U16_TRAIL(c), status);

   175     }else{

   176         ustr_ucat(dst, (UChar) c, status);

   177     }

   178 }

   179 U_CFUNC void

   180 ustr_uscat(struct UString *dst,

   181       const UChar* src,int len,

   182       UErrorCode *status)

   183 {

   184     if(U_FAILURE(*status))

   185         return;

   187     if(dst->fCapacity < (dst->fLength + len)) {

   188         ustr_resize(dst, ALLOCATION(dst->fLength + len), status);

   189         if(U_FAILURE(*status))

   190             return;

   191     }

   193     uprv_memcpy(dst->fChars + dst->fLength, src,

   194         sizeof(UChar) * len);

   195     dst->fLength += len;

   196     dst->fChars[dst->fLength] = 0x0000;

   197 }

   199 /* Destroys data in the string */

   200 static void

   201 ustr_resize(struct UString *s,

   202         int32_t len,

   203         UErrorCode *status)

   204 {

   205     if(U_FAILURE(*status))

   206         return;

   208     /* +1 for trailing 0x0000 */

   209     s->fChars = (UChar*) uprv_realloc(s->fChars, sizeof(UChar) * (len + 1));

   210     if(s->fChars == 0) {

   211         *status = U_MEMORY_ALLOCATION_ERROR;

   212         s->fLength = s->fCapacity = 0;

   213         return;

   214     }

   216     s->fCapacity = len;

   217 }

The Tor Browser / file revision