00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00021 #include "unicode/utypes.h"
00022 #include "unicode/ucnv_cb.h"
00023 #include "ucnv_bld.h"
00024 #include "cmemory.h"
00025
00026
00027
00028
00029
00030 void ucnv_cbFromUWriteBytes (UConverterFromUnicodeArgs *args,
00031 const char* source,
00032 int32_t length,
00033 int32_t offsetIndex,
00034 UErrorCode * err)
00035 {
00036 int32_t togo;
00037 int8_t toerr;
00038 int32_t i;
00039
00040 if((args->targetLimit - args->target) >= length)
00041 {
00042 uprv_memcpy(args->target, source, length);
00043 args->target += length;
00044 if(args->offsets)
00045 {
00046 for(i=0;i<length;i++)
00047 {
00048 *(args->offsets++) = offsetIndex;
00049 }
00050 }
00051 }
00052 else
00053 {
00054 togo = args->targetLimit - args->target;
00055
00056 uprv_memcpy(args->target, source, togo);
00057 args->target += togo;
00058
00059 if(args->offsets)
00060 {
00061 for(i=0;i<togo;i++)
00062 {
00063 *(args->offsets++) = offsetIndex;
00064 }
00065 }
00066
00067
00068 source += togo;
00069 toerr = (int8_t)(length - togo);
00070
00071 uprv_memcpy(args->converter->charErrorBuffer +
00072 args->converter->charErrorBufferLength,
00073 source,
00074 toerr * sizeof(source[0]));
00075 args->converter->charErrorBufferLength += toerr;
00076
00077 *err = U_BUFFER_OVERFLOW_ERROR;
00078
00079 }
00080 }
00081
00082 void ucnv_cbFromUWriteUChars(UConverterFromUnicodeArgs *args,
00083 const UChar** source,
00084 const UChar* sourceLimit,
00085 int32_t offsetIndex,
00086 UErrorCode * err)
00087 {
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100 char *oldTarget;
00101
00102 if(U_FAILURE(*err))
00103 {
00104 return;
00105 }
00106
00107 oldTarget = args->target;
00108
00109 ucnv_fromUnicode(args->converter,
00110 &args->target,
00111 args->targetLimit,
00112 source,
00113 sourceLimit,
00114 NULL,
00115 FALSE,
00116 err);
00117
00118 if(args->offsets)
00119 {
00120 while (args->target != oldTarget)
00121 {
00122 *(args->offsets)++ = offsetIndex;
00123 oldTarget++;
00124 }
00125 }
00126
00127
00128
00129
00130 if(*err == U_BUFFER_OVERFLOW_ERROR)
00131
00132
00133 {
00134
00135
00136 char *newTarget;
00137 const char *newTargetLimit;
00138 UErrorCode err2 = U_ZERO_ERROR;
00139
00140 int8_t errBuffLen;
00141
00142 errBuffLen = args->converter->charErrorBufferLength;
00143
00144
00145 newTarget = (char *)(args->converter->charErrorBuffer + errBuffLen);
00146
00147 newTargetLimit = (char *)(args->converter->charErrorBuffer +
00148 sizeof(args->converter->charErrorBuffer));
00149
00150 if(newTarget >= newTargetLimit)
00151 {
00152 *err = U_INTERNAL_PROGRAM_ERROR;
00153 return;
00154 }
00155
00156
00157
00158
00159
00160
00161 args->converter->charErrorBufferLength = 0;
00162
00163 ucnv_fromUnicode(args->converter,
00164 &newTarget,
00165 newTargetLimit,
00166 source,
00167 sourceLimit,
00168 NULL,
00169 FALSE,
00170 &err2);
00171
00172
00173
00174
00175 args->converter->charErrorBufferLength = (int8_t)(
00176 newTarget - (char*)args->converter->charErrorBuffer);
00177
00178 if((newTarget >= newTargetLimit) || (err2 == U_BUFFER_OVERFLOW_ERROR))
00179 {
00180
00181
00182
00183
00184 *err = U_INTERNAL_PROGRAM_ERROR;
00185 return;
00186 }
00187 else
00188 {
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198 }
00199 }
00200 }
00201
00202 void ucnv_cbFromUWriteSub (UConverterFromUnicodeArgs *args,
00203 int32_t offsetIndex,
00204 UErrorCode * err)
00205 {
00206 char togo[5];
00207 int32_t togoLen;
00208
00209 if(U_FAILURE(*err))
00210 {
00211 return;
00212 }
00213
00214
00215
00216 uprv_memcpy(togo, args->converter->subChar, togoLen = args->converter->subCharLen);
00217 if (ucnv_getType(args->converter) == UCNV_EBCDIC_STATEFUL)
00218 {
00219 if ((args->converter->fromUnicodeStatus)&&(togoLen != 2))
00220 {
00221 togo[0] = UCNV_SI;
00222 togo[1] = args->converter->subChar[0];
00223 togo[2] = UCNV_SO;
00224 togoLen = 3;
00225 }
00226 else if (!(args->converter->fromUnicodeStatus)&&(togoLen != 1))
00227 {
00228 togo[0] = UCNV_SO;
00229 togo[1] = args->converter->subChar[0];
00230 togo[2] = args->converter->subChar[1];
00231 togo[3] = UCNV_SI;
00232 togoLen = 4;
00233 }
00234 }
00235
00236
00237
00238 ucnv_cbFromUWriteBytes(args, togo, togoLen, offsetIndex, err);
00239
00240
00241 return;
00242 }
00243
00244 void ucnv_cbToUWriteUChars (UConverterToUnicodeArgs *args,
00245 const UChar* source,
00246 int32_t length,
00247 int32_t offsetIndex,
00248 UErrorCode * err)
00249 {
00250 int32_t togo;
00251 int8_t toerr;
00252 int32_t i;
00253
00254 if(U_FAILURE(*err))
00255 {
00256 return;
00257 }
00258
00259
00260 if((args->targetLimit - args->target) >= length)
00261 {
00262 uprv_memcpy(args->target, source, length * sizeof(args->target[0]) );
00263 args->target += length;
00264 if(args->offsets)
00265 {
00266 for(i=0;i<length;i++)
00267 {
00268 *(args->offsets++) = offsetIndex;
00269 }
00270 }
00271 }
00272 else
00273 {
00274 togo = args->targetLimit - args->target;
00275
00276 uprv_memcpy(args->target, source, togo * sizeof(args->target[0]) );
00277 args->target += togo;
00278
00279 if(args->offsets)
00280 {
00281 for(i=0;i<togo;i++)
00282 {
00283 *(args->offsets++) = offsetIndex;
00284 }
00285 }
00286
00287
00288 source += togo;
00289 toerr = (int8_t)(length - togo);
00290
00291 uprv_memcpy(args->converter->UCharErrorBuffer +
00292 args->converter->UCharErrorBufferLength,
00293 source,
00294 toerr * sizeof(source[0]));
00295 args->converter->UCharErrorBufferLength += toerr;
00296
00297 *err = U_BUFFER_OVERFLOW_ERROR;
00298 }
00299 }
00300
00301 void ucnv_cbToUWriteSub (UConverterToUnicodeArgs *args,
00302 int32_t offsetIndex,
00303 UErrorCode * err)
00304 {
00305 static const UChar kSubstituteChar = 0xFFFD ;
00306
00307
00308 ucnv_cbToUWriteUChars(args, &kSubstituteChar, 1, offsetIndex, err);
00309 }