U_CAPI int32_t U_EXPORT2
uspoof_areConfusableUnicodeString(const USpoofChecker *sc,
const icu::UnicodeString &s1,
const icu::UnicodeString &s2,
UErrorCode *status) {
const UChar *u1 = s1.getBuffer();
int32_t length1 = s1.length();
const UChar *u2 = s2.getBuffer();
int32_t length2 = s2.length();
int32_t results = uspoof_areConfusable(sc, u1, length1, u2, length2, status);
return results;
}
void FStringConverter::ConvertString(const TCHAR* Source, const int32 SourceStartIndex, const int32 SourceLen, icu::UnicodeString& Destination, const bool ShouldNullTerminate)
{
if (SourceLen > 0)
{
UErrorCode ICUStatus = U_ZERO_ERROR;
ucnv_reset(ICUConverter);
// Get the internal buffer of the string, we're going to use it as scratch space
const int32_t DestinationCapacityUChars = SourceLen * 2;
UChar* InternalStringBuffer = Destination.getBuffer(DestinationCapacityUChars);
// Perform the conversion into the string buffer
const int32_t SourceSizeBytes = SourceLen * sizeof(TCHAR);
const int32_t DestinationLength = ucnv_toUChars(ICUConverter, InternalStringBuffer, DestinationCapacityUChars, reinterpret_cast<const char*>(Source + SourceStartIndex), SourceSizeBytes, &ICUStatus);
// Optionally null terminate the string
if (ShouldNullTerminate)
{
InternalStringBuffer[DestinationLength] = 0;
}
// Size it back down to the correct size and release our lock on the string buffer
Destination.releaseBuffer(DestinationLength);
check(U_SUCCESS(ICUStatus));
}
else
{
Destination.remove();
}
}
U_CAPI int32_t U_EXPORT2
uspoof_checkUnicodeString(const USpoofChecker *sc,
const icu::UnicodeString &text,
int32_t *position,
UErrorCode *status) {
int32_t result = uspoof_check(sc, text.getBuffer(), text.length(), position, status);
return result;
}
/**
* Write an Unitex file content (to system filesystem or filespace)
* it write from two buffer (prefix and suffix). This is useful for writing both header and footer (or BOM and text...)
*/
UNITEX_FUNC int UNITEX_CALL WriteUnicodeUnitexFile(const char*filename, icu::UnicodeString const& uString)
{
UChar uBom = 0xfeff;
const UChar * uBuffer = uString.getBuffer();
int32_t uLength = uString.length();
bool result = WriteUnitexFile(filename, &uBom, sizeof(UChar), uBuffer, uLength * sizeof(UChar)) == 0;
return result;
}
bool ustring_from_char(icu::UnicodeString& ret,
const String& str,
UErrorCode &error) {
int32_t capacity = str.size() + 1;
UChar *utf16 = ret.getBuffer(capacity);
int32_t utf16_len = 0;
error = U_ZERO_ERROR;
u_strFromUTF8WithSub(utf16, ret.getCapacity(), &utf16_len,
str.c_str(), str.size(),
U_SENTINEL /* no substitution */,
nullptr, &error);
ret.releaseBuffer(utf16_len);
if (U_FAILURE(error)) {
ret.setToBogus();
return false;
}
return true;
}
static void
printLine(UChar32 start, UChar32 end, Status status, const icu::UnicodeString &mapping) {
if(start==end) {
printf("%04lX ", (long)start);
} else {
printf("%04lX..%04lX ", (long)start, (long)end);
}
printf("; %s", statusNames[status]);
if(status==MAPPED || status==DEVIATION || !mapping.isEmpty()) {
printf(" ;");
const UChar *buffer=mapping.getBuffer();
int32_t length=mapping.length();
int32_t i=0;
UChar32 c;
while(i<length) {
U16_NEXT(buffer, i, length, c);
printf(" %04lX", (long)c);
}
}
puts("");
}
static int
toIDNA2003(const UStringPrepProfile *prep, UChar32 c, icu::UnicodeString &destString) {
UChar src[2];
int32_t srcLength=0;
U16_APPEND_UNSAFE(src, srcLength, c);
UChar *dest;
int32_t destLength;
dest=destString.getBuffer(32);
if(dest==NULL) {
return FALSE;
}
UErrorCode errorCode=U_ZERO_ERROR;
destLength=usprep_prepare(prep, src, srcLength,
dest, destString.getCapacity(),
USPREP_DEFAULT, NULL, &errorCode);
destString.releaseBuffer(destLength);
if(errorCode==U_STRINGPREP_PROHIBITED_ERROR) {
return -1;
} else {
// Returns FALSE=0 for U_STRINGPREP_UNASSIGNED_ERROR and processing errors,
// TRUE=1 if c is valid or mapped.
return U_SUCCESS(errorCode);
}
}
jobject operator()(icu::UnicodeString const& value) const {
return env->NewString(value.getBuffer(), value.length());
}
void FStringConverter::ConvertString(const icu::UnicodeString& Source, const int32 SourceStartIndex, const int32 SourceLen, FString& Destination)
{
if (Source.length() > 0)
{
UErrorCode ICUStatus = U_ZERO_ERROR;
ucnv_reset(ICUConverter);
// Get the internal buffer of the string, we're going to use it as scratch space
TArray<TCHAR>& InternalStringBuffer = Destination.GetCharArray();
// Work out the maximum size required and resize the buffer so it can hold enough data
const int32_t DestinationCapacityBytes = UCNV_GET_MAX_BYTES_FOR_STRING(SourceLen, ucnv_getMaxCharSize(ICUConverter));
const int32 DestinationCapacityTCHARs = DestinationCapacityBytes / sizeof(TCHAR);
InternalStringBuffer.SetNumUninitialized(DestinationCapacityTCHARs);
// Perform the conversion into the string buffer, and then null terminate the FString and size it back down to the correct size
const int32_t DestinationSizeBytes = ucnv_fromUChars(ICUConverter, reinterpret_cast<char*>(InternalStringBuffer.GetData()), DestinationCapacityBytes, Source.getBuffer() + SourceStartIndex, SourceLen, &ICUStatus);
const int32 DestinationSizeTCHARs = DestinationSizeBytes / sizeof(TCHAR);
InternalStringBuffer[DestinationSizeTCHARs] = 0;
InternalStringBuffer.SetNum(DestinationSizeTCHARs + 1, /*bAllowShrinking*/false); // the array size includes null
check(U_SUCCESS(ICUStatus));
}
else
{
Destination.Empty();
}
}
QString
EnabledLocalesModel::unicodeStringToQString( const icu::UnicodeString& sourceStr )
{
return QString( reinterpret_cast<const QChar*>( sourceStr.getBuffer() ),
sourceStr.length() );
}
