src/utils_i18n_ustring.c

   1 /*
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16
  17 #include <unicode/ustring.h>
  18 #include <utils_i18n_ustring.h>
  19 #include <utils_i18n_private.h>
  20
  21 int32_t i18n_ustring_get_length ( const i18n_uchar *s )
  22 {
  23     if(s == NULL) {
  24         set_last_result(I18N_ERROR_INVALID_PARAMETER);
  25         return 0;
  26     }
  27
  28     set_last_result(I18N_ERROR_NONE);
  29     return u_strlen (s);
  30 }
  31
  32 int32_t i18n_ustring_count_char32 ( const i18n_uchar *s, int32_t length )
  33 {
  34     if(s == NULL || length < -1) {
  35         set_last_result(I18N_ERROR_INVALID_PARAMETER);
  36         return 0;
  37     }
  38
  39     set_last_result(I18N_ERROR_NONE);
  40     return u_countChar32(s, length);
  41 }
  42
  43 i18n_ubool i18n_ustring_has_more_char32_than ( const i18n_uchar *s, int32_t length, int32_t number )
  44 {
  45     if(s == NULL || length < -1) {
  46         set_last_result(I18N_ERROR_INVALID_PARAMETER);
  47         return false;
  48     }
  49
  50     set_last_result(I18N_ERROR_NONE);
  51     return u_strHasMoreChar32Than(s, length, number);
  52 }
  53
  54 i18n_uchar* i18n_ustring_cat ( i18n_uchar *dest, const i18n_uchar *src )
  55 {
  56     if(dest == NULL || src == NULL) {
  57         set_last_result(I18N_ERROR_INVALID_PARAMETER);
  58         return NULL;
  59     }
  60
  61     set_last_result(I18N_ERROR_NONE);
  62     return u_strcat(dest, src);
  63 }
  64
  65 i18n_uchar * i18n_ustring_cat_n ( i18n_uchar *dest, const i18n_uchar *src, int32_t n )
  66 {
  67     if(dest == NULL || src == NULL) {
  68         set_last_result(I18N_ERROR_INVALID_PARAMETER);
  69         return NULL;
  70     }
  71
  72     set_last_result(I18N_ERROR_NONE);
  73     return u_strncat(dest, src, n);
  74 }
  75
  76 i18n_uchar* i18n_ustring_string ( const i18n_uchar *s, const i18n_uchar *sub_string )
  77 {
  78     if(s == NULL) {
  79         set_last_result(I18N_ERROR_INVALID_PARAMETER);
  80         return NULL;
  81     }
  82
  83     set_last_result(I18N_ERROR_NONE);
  84     return (i18n_uchar*)u_strstr(s, sub_string);
  85 }
  86
  87 i18n_uchar* i18n_ustring_find_first ( const i18n_uchar *s, int32_t length, const i18n_uchar *sub_string, int32_t sub_length )
  88 {
  89     if(s == NULL || length < -1) {
  90         set_last_result(I18N_ERROR_INVALID_PARAMETER);
  91         return NULL;
  92     }
  93
  94     set_last_result(I18N_ERROR_NONE);
  95     return u_strFindFirst(s, length, sub_string, sub_length);
  96 }
  97
  98 i18n_uchar* i18n_ustring_char ( const i18n_uchar *s, i18n_uchar c )
  99 {
 100     if(s == NULL) {
 101         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 102         return NULL;
 103     }
 104
 105     set_last_result(I18N_ERROR_NONE);
 106     return (i18n_uchar*)u_strchr(s, c);
 107 }
 108
 109 i18n_uchar* i18n_ustring_char32 ( const i18n_uchar *s, i18n_uchar32 c )
 110 {
 111     if(s == NULL) {
 112         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 113         return NULL;
 114     }
 115
 116     set_last_result(I18N_ERROR_NONE);
 117     return (i18n_uchar*)u_strchr32(s, c);
 118 }
 119
 120 i18n_uchar* i18n_ustring_r_string ( const i18n_uchar *s, const i18n_uchar *sub_string )
 121 {
 122     if(s == NULL) {
 123         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 124         return NULL;
 125     }
 126
 127     set_last_result(I18N_ERROR_NONE);
 128     return (i18n_uchar*)u_strrstr(s, sub_string);
 129 }
 130
 131 i18n_uchar* i18n_ustring_find_last( const i18n_uchar *s, int32_t length, const i18n_uchar *sub_string, int32_t sub_length )
 132 {
 133     if(s == NULL || length < -1) {
 134         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 135         return NULL;
 136     }
 137
 138     set_last_result(I18N_ERROR_NONE);
 139     return (i18n_uchar*)u_strFindLast(s, length, sub_string, sub_length);
 140 }
 141
 142 i18n_uchar* i18n_ustring_r_char ( const i18n_uchar *s, i18n_uchar c )
 143 {
 144     if(s == NULL) {
 145         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 146         return NULL;
 147     }
 148
 149     set_last_result(I18N_ERROR_NONE);
 150     return (i18n_uchar*)u_strrchr(s, c);
 151 }
 152
 153 i18n_uchar* i18n_ustring_r_char32 ( const i18n_uchar *s, i18n_uchar32 c )
 154 {
 155     if(s == NULL) {
 156         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 157         return NULL;
 158     }
 159
 160     set_last_result(I18N_ERROR_NONE);
 161     return (i18n_uchar*)u_strrchr32(s, c);
 162 }
 163
 164 i18n_uchar* i18n_ustring_pbrk ( const i18n_uchar *string, const i18n_uchar *match_set )
 165 {
 166     if(string == NULL || match_set == NULL) {
 167         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 168         return NULL;
 169     }
 170
 171     set_last_result(I18N_ERROR_NONE);
 172     return (i18n_uchar*)u_strpbrk(string, match_set);
 173 }
 174
 175 int32_t i18n_ustring_cspn ( const i18n_uchar *string, const i18n_uchar *match_set )
 176 {
 177     if(string == NULL || match_set == NULL) {
 178         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 179         return 0;
 180     }
 181
 182     set_last_result(I18N_ERROR_NONE);
 183     return u_strcspn(string, match_set);
 184 }
 185
 186 int32_t i18n_ustring_spn ( const i18n_uchar *string, const i18n_uchar *match_set )
 187 {
 188     if(string == NULL || match_set == NULL) {
 189         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 190         return 0;
 191     }
 192
 193     set_last_result(I18N_ERROR_NONE);
 194     return u_strspn(string, match_set);
 195 }
 196
 197 i18n_uchar* i18n_ustring_tokenizer_r ( i18n_uchar *src, const i18n_uchar *delim, i18n_uchar **save_state )
 198 {
 199     if((src == NULL && save_state == NULL) || delim == NULL) {
 200         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 201         return NULL;
 202     }
 203
 204     set_last_result(I18N_ERROR_NONE);
 205     return u_strtok_r(src, delim, save_state);
 206 }
 207
 208 int32_t i18n_ustring_compare ( const i18n_uchar *s1, const i18n_uchar *s2 )
 209 {
 210     if(s1 == NULL || s2 == NULL) {
 211         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 212         return 0;
 213     }
 214
 215     set_last_result(I18N_ERROR_NONE);
 216     return u_strcmp (s1, s2);
 217 }
 218
 219 int32_t i18n_ustring_compare_code_point_order( const i18n_uchar *s1, const i18n_uchar *s2 )
 220 {
 221     if(s1 == NULL || s2 == NULL) {
 222         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 223         return 0;
 224     }
 225
 226     set_last_result(I18N_ERROR_NONE);
 227     return u_strcmpCodePointOrder(s1, s2);
 228 }
 229
 230 int32_t i18n_ustring_compare_binary_order( const i18n_uchar *s1, int32_t length1, const i18n_uchar *s2, int32_t length2, i18n_ubool code_point_order )
 231 {
 232     if(s1 == NULL || s2 == NULL) {
 233         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 234         return 0;
 235     }
 236
 237     set_last_result(I18N_ERROR_NONE);
 238     return u_strCompare(s1, length1,  s2, length2, code_point_order);
 239 }
 240
 241 int32_t i18n_ustring_case_compare_with_length( const i18n_uchar *s1, int32_t length1, const i18n_uchar *s2, int32_t length2, uint32_t options, i18n_error_code_e *i18n_error )
 242 {
 243     UErrorCode icu_error = U_ZERO_ERROR;
 244     int32_t result = u_strCaseCompare(s1, length1, s2, length2, options, &icu_error);
 245     *i18n_error = _i18n_error_mapping(icu_error);
 246     set_last_result(*i18n_error);
 247
 248     return result;
 249 }
 250
 251 int32_t i18n_ustring_compare_n( const i18n_uchar *s1, const i18n_uchar *s2, int32_t n )
 252 {
 253     if(s1 == NULL || s2 == NULL) {
 254         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 255         return 0;
 256     }
 257
 258     set_last_result(I18N_ERROR_NONE);
 259     return u_strncmp(s1, s2, n);
 260 }
 261
 262 int32_t i18n_ustring_compare_n_code_point_order( const i18n_uchar *s1, const i18n_uchar *s2, int32_t n )
 263 {
 264     if(s1 == NULL || s2 == NULL) {
 265         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 266         return 0;
 267     }
 268
 269     set_last_result(I18N_ERROR_NONE);
 270     return u_strncmpCodePointOrder(s1, s2, n);
 271 }
 272
 273 int32_t i18n_ustring_case_compare( const i18n_uchar *s1, const i18n_uchar *s2, uint32_t options )
 274 {
 275     if(s1 == NULL || s2 == NULL) {
 276         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 277         return 0;
 278     }
 279
 280     set_last_result(I18N_ERROR_NONE);
 281     return u_strcasecmp(s1, s2, options);
 282 }
 283
 284 int32_t i18n_ustring_case_compare_n( const i18n_uchar *s1, const i18n_uchar *s2, int32_t n, uint32_t options )
 285 {
 286     if(s1 == NULL || s2 == NULL) {
 287         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 288         return 0;
 289     }
 290
 291     set_last_result(I18N_ERROR_NONE);
 292     return u_strncasecmp(s1, s2, n, options);
 293 }
 294
 295 int32_t i18n_ustring_mem_case_compare( const i18n_uchar *s1, const i18n_uchar *s2, int32_t length, uint32_t options )
 296 {
 297     if(s1 == NULL || s2 == NULL) {
 298         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 299         return 0;
 300     }
 301
 302     set_last_result(I18N_ERROR_NONE);
 303     return u_memcasecmp(s1, s2, length, options);
 304 }
 305
 306 i18n_uchar* i18n_ustring_copy ( i18n_uchar *dest, const i18n_uchar *src )
 307 {
 308     if(dest == NULL || src == NULL) {
 309         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 310         return NULL;
 311     }
 312
 313     set_last_result(I18N_ERROR_NONE);
 314     return u_strcpy(dest, src);
 315 }
 316
 317 i18n_uchar* i18n_ustring_copy_n ( i18n_uchar *dest, const i18n_uchar *src, int32_t n )
 318 {
 319     if(dest == NULL || src == NULL) {
 320         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 321         return NULL;
 322     }
 323
 324     set_last_result(I18N_ERROR_NONE);
 325     return u_strncpy(dest, src, n);
 326 }
 327
 328 i18n_uchar* i18n_ustring_copy_ua ( i18n_uchar *dest, const char *src )
 329 {
 330     if(dest == NULL || src == NULL) {
 331         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 332         return NULL;
 333     }
 334
 335     set_last_result(I18N_ERROR_NONE);
 336     return u_uastrcpy(dest, src);
 337 }
 338
 339 i18n_uchar* i18n_ustring_copy_ua_n ( i18n_uchar *dest, const char *src, int32_t n )
 340 {
 341     if(dest == NULL || src == NULL) {
 342         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 343         return NULL;
 344     }
 345
 346     set_last_result(I18N_ERROR_NONE);
 347     return u_uastrncpy(dest, src, n);
 348 }
 349
 350 char* i18n_ustring_copy_au ( char *dest, const i18n_uchar *src )
 351 {
 352     if(dest == NULL || src == NULL) {
 353         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 354         return NULL;
 355     }
 356
 357     set_last_result(I18N_ERROR_NONE);
 358     return u_austrcpy(dest, src);
 359 }
 360
 361 char* i18n_ustring_copy_au_n ( char *dest, const i18n_uchar *src, int32_t n )
 362 {
 363     if(dest == NULL || src == NULL) {
 364         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 365         return NULL;
 366     }
 367
 368     set_last_result(I18N_ERROR_NONE);
 369     return u_austrncpy(dest, src, n);
 370 }
 371
 372 i18n_uchar* i18n_ustring_mem_copy ( i18n_uchar *dest, const i18n_uchar *src, int32_t count )
 373 {
 374     if(dest == NULL || src == NULL) {
 375         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 376         return NULL;
 377     }
 378
 379     set_last_result(I18N_ERROR_NONE);
 380     return u_memcpy(dest, src, count);
 381 }
 382
 383 i18n_uchar* i18n_ustring_mem_move ( i18n_uchar *dest, const i18n_uchar *src, int32_t count )
 384 {
 385     if(dest == NULL || src == NULL) {
 386         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 387         return NULL;
 388     }
 389
 390     set_last_result(I18N_ERROR_NONE);
 391     return u_memmove(dest, src, count);
 392 }
 393
 394 i18n_uchar* i18n_ustring_mem_set ( i18n_uchar *dest, const i18n_uchar c, int32_t count )
 395 {
 396     if(dest == NULL) {
 397         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 398         return NULL;
 399     }
 400
 401     set_last_result(I18N_ERROR_NONE);
 402     return u_memset(dest, c, count);
 403 }
 404
 405 int32_t i18n_ustring_mem_compare ( const i18n_uchar *buf1, const i18n_uchar *buf2, int32_t count )
 406 {
 407     if(buf1 == NULL || buf2 == NULL) {
 408         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 409         return 0;
 410     }
 411
 412     set_last_result(I18N_ERROR_NONE);
 413     return u_memcmp(buf1, buf2, count);
 414 }
 415
 416 int32_t i18n_ustring_mem_compare_code_point_order ( const i18n_uchar *s1, const i18n_uchar *s2, int32_t count )
 417 {
 418     if(s1 == NULL || s2 == NULL) {
 419         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 420         return 0;
 421     }
 422
 423     set_last_result(I18N_ERROR_NONE);
 424     return u_memcmpCodePointOrder(s1, s2, count);
 425 }
 426
 427 i18n_uchar* i18n_ustring_mem_char ( const i18n_uchar *s, i18n_uchar c, int32_t count )
 428 {
 429     if(s == NULL) {
 430         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 431         return NULL;
 432     }
 433
 434     set_last_result(I18N_ERROR_NONE);
 435     return (i18n_uchar*)u_memchr(s, c, count);
 436 }
 437
 438 i18n_uchar* i18n_ustring_mem_char32 ( const i18n_uchar *s, i18n_uchar32 c, int32_t count )
 439 {
 440     if(s == NULL) {
 441         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 442         return NULL;
 443     }
 444
 445     set_last_result(I18N_ERROR_NONE);
 446     return (i18n_uchar*)u_memchr32(s, c, count);
 447 }
 448
 449 i18n_uchar* i18n_ustring_mem_r_char ( const i18n_uchar *s, i18n_uchar c, int32_t count )
 450 {
 451     if(s == NULL) {
 452         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 453         return NULL;
 454     }
 455
 456     set_last_result(I18N_ERROR_NONE);
 457     return (i18n_uchar*)u_memrchr(s, c, count);
 458 }
 459
 460 i18n_uchar* i18n_ustring_mem_r_char32 ( const i18n_uchar *s, i18n_uchar32 c, int32_t count )
 461 {
 462     if(s == NULL) {
 463         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 464         return NULL;
 465     }
 466
 467     set_last_result(I18N_ERROR_NONE);
 468     return (i18n_uchar*)u_memrchr32(s, c, count);
 469 }
 470
 471 int32_t i18n_ustring_unescape ( const char *src, i18n_uchar *dest, int32_t dest_capacity )
 472 {
 473     if(dest == NULL || src == NULL) {
 474         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 475         return 0;
 476     }
 477
 478     set_last_result(I18N_ERROR_NONE);
 479     return u_unescape(src, dest, dest_capacity);
 480 }
 481
 482 i18n_uchar32 i18n_ustring_unescape_at ( i18n_ustring_unescape_char_at_cb char_at, int32_t *offset, int32_t length, void *context )
 483 {
 484     if(char_at == NULL || offset == NULL) {
 485         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 486         return 0;
 487     }
 488
 489     set_last_result(I18N_ERROR_NONE);
 490     return u_unescapeAt(char_at, offset, length, context);
 491 }
 492
 493 int32_t i18n_ustring_to_upper ( i18n_uchar *dest, int32_t dest_capacity, const i18n_uchar *src, int32_t src_len, const char *locale, i18n_error_code_e *i18n_error )
 494 {
 495    UErrorCode icu_error = U_ZERO_ERROR;
 496     int32_t result = u_strToUpper (dest, dest_capacity, src, src_len, locale, &icu_error);
 497     *i18n_error = _i18n_error_mapping(icu_error);
 498     set_last_result(*i18n_error);
 499
 500     return result;
 501 }
 502
 503 int32_t i18n_ustring_to_lower ( i18n_uchar *dest, int32_t dest_capacity, const i18n_uchar *src, int32_t src_len, const char *locale, i18n_error_code_e *i18n_error )
 504 {
 505    UErrorCode icu_error = U_ZERO_ERROR;
 506     int32_t result = u_strToLower (dest, dest_capacity, src, src_len, locale, &icu_error);
 507     *i18n_error = _i18n_error_mapping(icu_error);
 508     set_last_result(*i18n_error);
 509
 510     return result;
 511 }
 512
 513 int32_t i18n_ustring_to_title ( i18n_uchar *dest, int32_t dest_capacity, const i18n_uchar *src, int32_t src_len, i18n_ubreak_iterator_s *title_iter,
 514         const char *locale, i18n_error_code_e *i18n_error )
 515 {
 516     if(src == NULL) {
 517         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 518         *i18n_error = I18N_ERROR_INVALID_PARAMETER;
 519         return 0;
 520     }
 521
 522     UErrorCode icu_error = U_ZERO_ERROR;
 523     int32_t result = u_strToTitle (dest, dest_capacity, src, src_len, (UBreakIterator*)title_iter, locale, &icu_error);
 524     *i18n_error = _i18n_error_mapping(icu_error);
 525     set_last_result(*i18n_error);
 526
 527     return result;
 528 }
 529
 530 int32_t i18n_ustring_to_title_new ( i18n_uchar *dest, int32_t dest_capacity, const i18n_uchar *src,
 531         int32_t src_len, i18n_ubreak_iterator_h title_iter, const char *locale)
 532 {
 533     UErrorCode err = U_ZERO_ERROR;
 534     int32_t result = u_strToTitle (dest, dest_capacity, src, src_len, (UBreakIterator*)title_iter, locale, &err);
 535     set_last_result(_i18n_error_mapping(err));
 536
 537     return result;
 538 }
 539
 540 int32_t i18n_ustring_fold_case ( i18n_uchar *dest, int32_t dest_capacity, const i18n_uchar *src, int32_t src_len, uint32_t options, i18n_error_code_e *i18n_error )
 541 {
 542     if(src == NULL) {
 543         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 544         *i18n_error = I18N_ERROR_INVALID_PARAMETER;
 545         return 0;
 546     }
 547
 548    UErrorCode icu_error = U_ZERO_ERROR;
 549     int32_t result =u_strFoldCase (dest, dest_capacity, src, src_len, options, &icu_error);
 550     *i18n_error = _i18n_error_mapping(icu_error);
 551     set_last_result(*i18n_error);
 552
 553     return result;
 554 }
 555
 556 wchar_t* i18n_ustring_to_WCS ( wchar_t *dest, int32_t dest_capacity, int32_t *dest_len, const i18n_uchar *src, int32_t src_len, i18n_error_code_e *i18n_error )
 557 {
 558     if(src == NULL) {
 559         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 560         *i18n_error = I18N_ERROR_INVALID_PARAMETER;
 561         return NULL;
 562     }
 563
 564    UErrorCode icu_error = U_ZERO_ERROR;
 565     wchar_t* result = u_strToWCS (dest, dest_capacity, dest_len, src, src_len, &icu_error);
 566     *i18n_error = _i18n_error_mapping(icu_error);
 567     set_last_result(*i18n_error);
 568
 569     return result;
 570 }
 571
 572 i18n_uchar* i18n_ustring_from_WCS ( i18n_uchar *dest, int32_t dest_capacity, int32_t *dest_len, const wchar_t *src, int32_t src_len, i18n_error_code_e *i18n_error )
 573 {
 574     if(src == NULL) {
 575         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 576         *i18n_error = I18N_ERROR_INVALID_PARAMETER;
 577         return NULL;
 578     }
 579
 580    UErrorCode icu_error = U_ZERO_ERROR;
 581     i18n_uchar* result = u_strFromWCS (dest, dest_capacity, dest_len, src, src_len, &icu_error);
 582     *i18n_error = _i18n_error_mapping(icu_error);
 583     set_last_result(*i18n_error);
 584
 585     return result;
 586 }
 587
 588 char* i18n_ustring_to_UTF8 ( char *dest, int32_t dest_capacity, int32_t *dest_len, const i18n_uchar *src, int32_t src_len, i18n_error_code_e *i18n_error )
 589 {
 590     if(src == NULL) {
 591         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 592         *i18n_error = I18N_ERROR_INVALID_PARAMETER;
 593         return NULL;
 594     }
 595
 596    UErrorCode icu_error = U_ZERO_ERROR;
 597     char* result = u_strToUTF8 (dest, dest_capacity, dest_len, src, src_len, &icu_error);
 598     *i18n_error = _i18n_error_mapping(icu_error);
 599     set_last_result(*i18n_error);
 600
 601     return result;
 602 }
 603
 604 i18n_uchar* i18n_ustring_from_UTF8 ( i18n_uchar *dest, int32_t dest_capacity, int32_t *dest_len, const char *src, int32_t src_len, i18n_error_code_e *i18n_error )
 605 {
 606     if(src == NULL) {
 607         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 608         *i18n_error = I18N_ERROR_INVALID_PARAMETER;
 609         return NULL;
 610     }
 611
 612    UErrorCode icu_error = U_ZERO_ERROR;
 613     i18n_uchar* result = u_strFromUTF8 (dest, dest_capacity, dest_len, src, src_len, &icu_error);
 614     *i18n_error = _i18n_error_mapping(icu_error);
 615     set_last_result(*i18n_error);
 616
 617     return result;
 618 }
 619
 620 char* i18n_ustring_to_UTF8_with_sub ( char *dest, int32_t dest_capacity, int32_t *dest_len, const i18n_uchar *src, int32_t src_len, i18n_uchar32 sub_char, int32_t *num_substitutions, i18n_error_code_e *i18n_error )
 621 {
 622     if(src == NULL) {
 623         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 624         *i18n_error = I18N_ERROR_INVALID_PARAMETER;
 625         return NULL;
 626     }
 627
 628     UErrorCode icu_error = U_ZERO_ERROR;
 629     char* result = u_strToUTF8WithSub (dest, dest_capacity, dest_len, src, src_len, sub_char, num_substitutions, &icu_error);
 630     *i18n_error = _i18n_error_mapping(icu_error);
 631     set_last_result(*i18n_error);
 632
 633     return result;
 634 }
 635
 636 i18n_uchar* i18n_ustring_from_UTF8_with_sub ( i18n_uchar *dest, int32_t dest_capacity, int32_t *dest_len, const char *src, int32_t src_len, i18n_uchar32 sub_char,
 637     int32_t *num_substitutions, i18n_error_code_e *i18n_error )
 638 {
 639     if(src == NULL) {
 640         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 641         *i18n_error = I18N_ERROR_INVALID_PARAMETER;
 642         return NULL;
 643     }
 644
 645    UErrorCode icu_error = U_ZERO_ERROR;
 646     i18n_uchar* result = u_strFromUTF8WithSub (dest, dest_capacity, dest_len, src, src_len, sub_char, num_substitutions, &icu_error);
 647     *i18n_error = _i18n_error_mapping(icu_error);
 648     set_last_result(*i18n_error);
 649
 650     return result;
 651 }
 652
 653 i18n_uchar* i18n_ustring_from_UTF8_lenient ( i18n_uchar *dest, int32_t dest_capacity, int32_t *dest_len, const char *src, int32_t src_len, i18n_error_code_e *i18n_error )
 654 {
 655     if(src == NULL) {
 656         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 657         *i18n_error = I18N_ERROR_INVALID_PARAMETER;
 658         return NULL;
 659     }
 660
 661    UErrorCode icu_error = U_ZERO_ERROR;
 662     i18n_uchar* result = u_strFromUTF8Lenient (dest, dest_capacity, dest_len, src, src_len, &icu_error);
 663     *i18n_error = _i18n_error_mapping(icu_error);
 664     set_last_result(*i18n_error);
 665
 666     return result;
 667 }
 668
 669 i18n_uchar32* i18n_ustring_to_UTF32 ( i18n_uchar32 *dest, int32_t dest_capacity, int32_t *dest_len, const i18n_uchar *src, int32_t src_len, i18n_error_code_e *i18n_error )
 670 {
 671     if(src == NULL) {
 672         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 673         *i18n_error = I18N_ERROR_INVALID_PARAMETER;
 674         return NULL;
 675     }
 676
 677    UErrorCode icu_error = U_ZERO_ERROR;
 678     i18n_uchar32* result = u_strToUTF32 (dest, dest_capacity, dest_len, src, src_len, &icu_error);
 679     *i18n_error = _i18n_error_mapping(icu_error);
 680     set_last_result(*i18n_error);
 681
 682     return result;
 683 }
 684
 685 i18n_uchar* i18n_ustring_from_UTF32 ( i18n_uchar *dest, int32_t dest_capacity, int32_t *dest_len, const i18n_uchar32 *src, int32_t src_len, i18n_error_code_e *i18n_error )
 686 {
 687     if(src == NULL) {
 688         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 689         *i18n_error = I18N_ERROR_INVALID_PARAMETER;
 690         return NULL;
 691     }
 692
 693    UErrorCode icu_error = U_ZERO_ERROR;
 694     i18n_uchar* result = u_strFromUTF32 (dest, dest_capacity, dest_len, src, src_len, &icu_error);
 695     *i18n_error = _i18n_error_mapping(icu_error);
 696     set_last_result(*i18n_error);
 697
 698     return result;
 699 }
 700
 701 i18n_uchar32* i18n_ustring_to_UTF32_with_sub ( i18n_uchar32 *dest, int32_t dest_capacity, int32_t *dest_len, const i18n_uchar *src, int32_t src_len,
 702         i18n_uchar32 sub_char, int32_t *num_substitutions, i18n_error_code_e *i18n_error )
 703 {
 704     if(src == NULL) {
 705         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 706         *i18n_error = I18N_ERROR_INVALID_PARAMETER;
 707         return NULL;
 708     }
 709
 710    UErrorCode icu_error = U_ZERO_ERROR;
 711     i18n_uchar32* result = u_strToUTF32WithSub (dest, dest_capacity, dest_len, src, src_len, sub_char, num_substitutions, &icu_error);
 712     *i18n_error = _i18n_error_mapping(icu_error);
 713     set_last_result(*i18n_error);
 714
 715     return result;
 716 }
 717
 718 i18n_uchar* i18n_ustring_from_UTF32_with_sub ( i18n_uchar *dest, int32_t dest_capacity, int32_t *dest_len, const i18n_uchar32 *src, int32_t src_len, i18n_uchar32 sub_char, int32_t *num_substitutions, i18n_error_code_e *i18n_error )
 719 {
 720     if(src == NULL) {
 721         set_last_result(I18N_ERROR_INVALID_PARAMETER);
 722         *i18n_error = I18N_ERROR_INVALID_PARAMETER;
 723         return NULL;
 724     }
 725
 726     UErrorCode icu_error = U_ZERO_ERROR;
 727     i18n_uchar* result = u_strFromUTF32WithSub (dest, dest_capacity, dest_len, src, src_len, sub_char, num_substitutions, (UErrorCode*)&icu_error);
 728     *i18n_error = _i18n_error_mapping(icu_error);
 729     set_last_result(*i18n_error);
 730
 731     return result;
 732 }
 733