The Tor Browser / file comparison
comparison: intl/icu/source/common/ucnv_cnv.c
intl/icu/source/common/ucnv_cnv.c
- branch
- TOR_BUG_3246
- changeset 4
- fc2d59ddac77
equal
deleted
inserted
replaced
| -1:000000000000 | 0:a0c8565fe849 |
|---|---|
| 1 /* | |
| 2 ****************************************************************************** | |
| 3 * | |
| 4 * Copyright (C) 1999-2004, International Business Machines | |
| 5 * Corporation and others. All Rights Reserved. | |
| 6 * | |
| 7 ****************************************************************************** | |
| 8 * | |
| 9 * uconv_cnv.c: | |
| 10 * Implements all the low level conversion functions | |
| 11 * T_UnicodeConverter_{to,from}Unicode_$ConversionType | |
| 12 * | |
| 13 * Change history: | |
| 14 * | |
| 15 * 06/29/2000 helena Major rewrite of the callback APIs. | |
| 16 */ | |
| 17 | |
| 18 #include "unicode/utypes.h" | |
| 19 | |
| 20 #if !UCONFIG_NO_CONVERSION | |
| 21 | |
| 22 #include "unicode/ucnv_err.h" | |
| 23 #include "unicode/ucnv.h" | |
| 24 #include "unicode/uset.h" | |
| 25 #include "ucnv_cnv.h" | |
| 26 #include "ucnv_bld.h" | |
| 27 #include "cmemory.h" | |
| 28 | |
| 29 U_CFUNC void | |
| 30 ucnv_getCompleteUnicodeSet(const UConverter *cnv, | |
| 31 const USetAdder *sa, | |
| 32 UConverterUnicodeSet which, | |
| 33 UErrorCode *pErrorCode) { | |
| 34 sa->addRange(sa->set, 0, 0x10ffff); | |
| 35 } | |
| 36 | |
| 37 U_CFUNC void | |
| 38 ucnv_getNonSurrogateUnicodeSet(const UConverter *cnv, | |
| 39 const USetAdder *sa, | |
| 40 UConverterUnicodeSet which, | |
| 41 UErrorCode *pErrorCode) { | |
| 42 sa->addRange(sa->set, 0, 0xd7ff); | |
| 43 sa->addRange(sa->set, 0xe000, 0x10ffff); | |
| 44 } | |
| 45 | |
| 46 U_CFUNC void | |
| 47 ucnv_fromUWriteBytes(UConverter *cnv, | |
| 48 const char *bytes, int32_t length, | |
| 49 char **target, const char *targetLimit, | |
| 50 int32_t **offsets, | |
| 51 int32_t sourceIndex, | |
| 52 UErrorCode *pErrorCode) { | |
| 53 char *t=*target; | |
| 54 int32_t *o; | |
| 55 | |
| 56 /* write bytes */ | |
| 57 if(offsets==NULL || (o=*offsets)==NULL) { | |
| 58 while(length>0 && t<targetLimit) { | |
| 59 *t++=*bytes++; | |
| 60 --length; | |
| 61 } | |
| 62 } else { | |
| 63 /* output with offsets */ | |
| 64 while(length>0 && t<targetLimit) { | |
| 65 *t++=*bytes++; | |
| 66 *o++=sourceIndex; | |
| 67 --length; | |
| 68 } | |
| 69 *offsets=o; | |
| 70 } | |
| 71 *target=t; | |
| 72 | |
| 73 /* write overflow */ | |
| 74 if(length>0) { | |
| 75 if(cnv!=NULL) { | |
| 76 t=(char *)cnv->charErrorBuffer; | |
| 77 cnv->charErrorBufferLength=(int8_t)length; | |
| 78 do { | |
| 79 *t++=(uint8_t)*bytes++; | |
| 80 } while(--length>0); | |
| 81 } | |
| 82 *pErrorCode=U_BUFFER_OVERFLOW_ERROR; | |
| 83 } | |
| 84 } | |
| 85 | |
| 86 U_CFUNC void | |
| 87 ucnv_toUWriteUChars(UConverter *cnv, | |
| 88 const UChar *uchars, int32_t length, | |
| 89 UChar **target, const UChar *targetLimit, | |
| 90 int32_t **offsets, | |
| 91 int32_t sourceIndex, | |
| 92 UErrorCode *pErrorCode) { | |
| 93 UChar *t=*target; | |
| 94 int32_t *o; | |
| 95 | |
| 96 /* write UChars */ | |
| 97 if(offsets==NULL || (o=*offsets)==NULL) { | |
| 98 while(length>0 && t<targetLimit) { | |
| 99 *t++=*uchars++; | |
| 100 --length; | |
| 101 } | |
| 102 } else { | |
| 103 /* output with offsets */ | |
| 104 while(length>0 && t<targetLimit) { | |
| 105 *t++=*uchars++; | |
| 106 *o++=sourceIndex; | |
| 107 --length; | |
| 108 } | |
| 109 *offsets=o; | |
| 110 } | |
| 111 *target=t; | |
| 112 | |
| 113 /* write overflow */ | |
| 114 if(length>0) { | |
| 115 if(cnv!=NULL) { | |
| 116 t=cnv->UCharErrorBuffer; | |
| 117 cnv->UCharErrorBufferLength=(int8_t)length; | |
| 118 do { | |
| 119 *t++=*uchars++; | |
| 120 } while(--length>0); | |
| 121 } | |
| 122 *pErrorCode=U_BUFFER_OVERFLOW_ERROR; | |
| 123 } | |
| 124 } | |
| 125 | |
| 126 U_CFUNC void | |
| 127 ucnv_toUWriteCodePoint(UConverter *cnv, | |
| 128 UChar32 c, | |
| 129 UChar **target, const UChar *targetLimit, | |
| 130 int32_t **offsets, | |
| 131 int32_t sourceIndex, | |
| 132 UErrorCode *pErrorCode) { | |
| 133 UChar *t; | |
| 134 int32_t *o; | |
| 135 | |
| 136 t=*target; | |
| 137 | |
| 138 if(t<targetLimit) { | |
| 139 if(c<=0xffff) { | |
| 140 *t++=(UChar)c; | |
| 141 c=U_SENTINEL; | |
| 142 } else /* c is a supplementary code point */ { | |
| 143 *t++=U16_LEAD(c); | |
| 144 c=U16_TRAIL(c); | |
| 145 if(t<targetLimit) { | |
| 146 *t++=(UChar)c; | |
| 147 c=U_SENTINEL; | |
| 148 } | |
| 149 } | |
| 150 | |
| 151 /* write offsets */ | |
| 152 if(offsets!=NULL && (o=*offsets)!=NULL) { | |
| 153 *o++=sourceIndex; | |
| 154 if((*target+1)<t) { | |
| 155 *o++=sourceIndex; | |
| 156 } | |
| 157 *offsets=o; | |
| 158 } | |
| 159 } | |
| 160 | |
| 161 *target=t; | |
| 162 | |
| 163 /* write overflow from c */ | |
| 164 if(c>=0) { | |
| 165 if(cnv!=NULL) { | |
| 166 int8_t i=0; | |
| 167 U16_APPEND_UNSAFE(cnv->UCharErrorBuffer, i, c); | |
| 168 cnv->UCharErrorBufferLength=i; | |
| 169 } | |
| 170 *pErrorCode=U_BUFFER_OVERFLOW_ERROR; | |
| 171 } | |
| 172 } | |
| 173 | |
| 174 #endif |
