| // © 2016 and later: Unicode, Inc. and others. | |
| // License & terms of use: http://www.unicode.org/copyright.html | |
| /* | |
| ******************************************************************************* | |
| * | |
| * Copyright (C) 1998-2014, International Business Machines | |
| * Corporation and others. All Rights Reserved. | |
| * | |
| ******************************************************************************* | |
| * file name: ustr_cnv.cpp | |
| * encoding: UTF-8 | |
| * tab size: 8 (not used) | |
| * indentation:4 | |
| * | |
| * created on: 2004aug24 | |
| * created by: Markus W. Scherer | |
| * | |
| * Character conversion functions moved here from ustring.c | |
| */ | |
| #include "unicode/utypes.h" | |
| #if !UCONFIG_NO_CONVERSION | |
| #include "unicode/ustring.h" | |
| #include "unicode/ucnv.h" | |
| #include "cstring.h" | |
| #include "cmemory.h" | |
| #include "umutex.h" | |
| #include "ustr_cnv.h" | |
| #include "ucnv_bld.h" | |
| /* mutexed access to a shared default converter ----------------------------- */ | |
| static UConverter *gDefaultConverter = NULL; | |
| U_CAPI UConverter* U_EXPORT2 | |
| u_getDefaultConverter(UErrorCode *status) | |
| { | |
| UConverter *converter = NULL; | |
| if (gDefaultConverter != NULL) { | |
| icu::umtx_lock(NULL); | |
| /* need to check to make sure it wasn't taken out from under us */ | |
| if (gDefaultConverter != NULL) { | |
| converter = gDefaultConverter; | |
| gDefaultConverter = NULL; | |
| } | |
| icu::umtx_unlock(NULL); | |
| } | |
| /* if the cache was empty, create a converter */ | |
| if(converter == NULL) { | |
| converter = ucnv_open(NULL, status); | |
| if(U_FAILURE(*status)) { | |
| ucnv_close(converter); | |
| converter = NULL; | |
| } | |
| } | |
| return converter; | |
| } | |
| U_CAPI void U_EXPORT2 | |
| u_releaseDefaultConverter(UConverter *converter) | |
| { | |
| if(gDefaultConverter == NULL) { | |
| if (converter != NULL) { | |
| ucnv_reset(converter); | |
| } | |
| ucnv_enableCleanup(); | |
| icu::umtx_lock(NULL); | |
| if(gDefaultConverter == NULL) { | |
| gDefaultConverter = converter; | |
| converter = NULL; | |
| } | |
| icu::umtx_unlock(NULL); | |
| } | |
| if(converter != NULL) { | |
| ucnv_close(converter); | |
| } | |
| } | |
| U_CAPI void U_EXPORT2 | |
| u_flushDefaultConverter() | |
| { | |
| UConverter *converter = NULL; | |
| if (gDefaultConverter != NULL) { | |
| icu::umtx_lock(NULL); | |
| /* need to check to make sure it wasn't taken out from under us */ | |
| if (gDefaultConverter != NULL) { | |
| converter = gDefaultConverter; | |
| gDefaultConverter = NULL; | |
| } | |
| icu::umtx_unlock(NULL); | |
| } | |
| /* if the cache was populated, flush it */ | |
| if(converter != NULL) { | |
| ucnv_close(converter); | |
| } | |
| } | |
| /* conversions between char* and UChar* ------------------------------------- */ | |
| /* maximum string length for u_uastrcpy() and u_austrcpy() implementations */ | |
| #define MAX_STRLEN 0x0FFFFFFF | |
| /* | |
| returns the minimum of (the length of the null-terminated string) and n. | |
| */ | |
| static int32_t u_astrnlen(const char *s1, int32_t n) | |
| { | |
| int32_t len = 0; | |
| if (s1) | |
| { | |
| while (n-- && *(s1++)) | |
| { | |
| len++; | |
| } | |
| } | |
| return len; | |
| } | |
| U_CAPI UChar* U_EXPORT2 | |
| u_uastrncpy(UChar *ucs1, | |
| const char *s2, | |
| int32_t n) | |
| { | |
| UChar *target = ucs1; | |
| UErrorCode err = U_ZERO_ERROR; | |
| UConverter *cnv = u_getDefaultConverter(&err); | |
| if(U_SUCCESS(err) && cnv != NULL) { | |
| ucnv_reset(cnv); | |
| ucnv_toUnicode(cnv, | |
| &target, | |
| ucs1+n, | |
| &s2, | |
| s2+u_astrnlen(s2, n), | |
| NULL, | |
| TRUE, | |
| &err); | |
| ucnv_reset(cnv); /* be good citizens */ | |
| u_releaseDefaultConverter(cnv); | |
| if(U_FAILURE(err) && (err != U_BUFFER_OVERFLOW_ERROR) ) { | |
| *ucs1 = 0; /* failure */ | |
| } | |
| if(target < (ucs1+n)) { /* U_BUFFER_OVERFLOW_ERROR isn't an err, just means no termination will happen. */ | |
| *target = 0; /* terminate */ | |
| } | |
| } else { | |
| *ucs1 = 0; | |
| } | |
| return ucs1; | |
| } | |
| U_CAPI UChar* U_EXPORT2 | |
| u_uastrcpy(UChar *ucs1, | |
| const char *s2 ) | |
| { | |
| UErrorCode err = U_ZERO_ERROR; | |
| UConverter *cnv = u_getDefaultConverter(&err); | |
| if(U_SUCCESS(err) && cnv != NULL) { | |
| ucnv_toUChars(cnv, | |
| ucs1, | |
| MAX_STRLEN, | |
| s2, | |
| (int32_t)uprv_strlen(s2), | |
| &err); | |
| u_releaseDefaultConverter(cnv); | |
| if(U_FAILURE(err)) { | |
| *ucs1 = 0; | |
| } | |
| } else { | |
| *ucs1 = 0; | |
| } | |
| return ucs1; | |
| } | |
| /* | |
| returns the minimum of (the length of the null-terminated string) and n. | |
| */ | |
| static int32_t u_ustrnlen(const UChar *ucs1, int32_t n) | |
| { | |
| int32_t len = 0; | |
| if (ucs1) | |
| { | |
| while (n-- && *(ucs1++)) | |
| { | |
| len++; | |
| } | |
| } | |
| return len; | |
| } | |
| U_CAPI char* U_EXPORT2 | |
| u_austrncpy(char *s1, | |
| const UChar *ucs2, | |
| int32_t n) | |
| { | |
| char *target = s1; | |
| UErrorCode err = U_ZERO_ERROR; | |
| UConverter *cnv = u_getDefaultConverter(&err); | |
| if(U_SUCCESS(err) && cnv != NULL) { | |
| ucnv_reset(cnv); | |
| ucnv_fromUnicode(cnv, | |
| &target, | |
| s1+n, | |
| &ucs2, | |
| ucs2+u_ustrnlen(ucs2, n), | |
| NULL, | |
| TRUE, | |
| &err); | |
| ucnv_reset(cnv); /* be good citizens */ | |
| u_releaseDefaultConverter(cnv); | |
| if(U_FAILURE(err) && (err != U_BUFFER_OVERFLOW_ERROR) ) { | |
| *s1 = 0; /* failure */ | |
| } | |
| if(target < (s1+n)) { /* U_BUFFER_OVERFLOW_ERROR isn't an err, just means no termination will happen. */ | |
| *target = 0; /* terminate */ | |
| } | |
| } else { | |
| *s1 = 0; | |
| } | |
| return s1; | |
| } | |
| U_CAPI char* U_EXPORT2 | |
| u_austrcpy(char *s1, | |
| const UChar *ucs2 ) | |
| { | |
| UErrorCode err = U_ZERO_ERROR; | |
| UConverter *cnv = u_getDefaultConverter(&err); | |
| if(U_SUCCESS(err) && cnv != NULL) { | |
| int32_t len = ucnv_fromUChars(cnv, | |
| s1, | |
| MAX_STRLEN, | |
| ucs2, | |
| -1, | |
| &err); | |
| u_releaseDefaultConverter(cnv); | |
| s1[len] = 0; | |
| } else { | |
| *s1 = 0; | |
| } | |
| return s1; | |
| } | |
| #endif |