Lines Matching refs:status
31 uspoof_open(UErrorCode *status) {
32 if (U_FAILURE(*status)) {
35 SpoofImpl *si = new SpoofImpl(SpoofData::getDefault(*status), *status);
36 if (U_FAILURE(*status)) {
46 UErrorCode *status) {
47 if (U_FAILURE(*status)) {
50 SpoofData *sd = new SpoofData(data, length, *status);
51 SpoofImpl *si = new SpoofImpl(sd, *status);
52 if (U_FAILURE(*status)) {
58 *status = U_MEMORY_ALLOCATION_ERROR;
72 uspoof_clone(const USpoofChecker *sc, UErrorCode *status) {
73 const SpoofImpl *src = SpoofImpl::validateThis(sc, *status);
77 SpoofImpl *result = new SpoofImpl(*src, *status); // copy constructor
78 if (U_FAILURE(*status)) {
88 UErrorCode status = U_ZERO_ERROR;
89 SpoofImpl *This = SpoofImpl::validateThis(sc, status);
95 uspoof_setChecks(USpoofChecker *sc, int32_t checks, UErrorCode *status) {
96 SpoofImpl *This = SpoofImpl::validateThis(sc, *status);
104 *status = U_ILLEGAL_ARGUMENT_ERROR;
113 uspoof_getChecks(const USpoofChecker *sc, UErrorCode *status) {
114 const SpoofImpl *This = SpoofImpl::validateThis(sc, *status);
122 uspoof_setAllowedLocales(USpoofChecker *sc, const char *localesList, UErrorCode *status) {
123 SpoofImpl *This = SpoofImpl::validateThis(sc, *status);
127 This->setAllowedLocales(localesList, *status);
131 uspoof_getAllowedLocales(USpoofChecker *sc, UErrorCode *status) {
132 SpoofImpl *This = SpoofImpl::validateThis(sc, *status);
136 return This->getAllowedLocales(*status);
141 uspoof_getAllowedChars(const USpoofChecker *sc, UErrorCode *status) {
142 const UnicodeSet *result = uspoof_getAllowedUnicodeSet(sc, status);
147 uspoof_getAllowedUnicodeSet(const USpoofChecker *sc, UErrorCode *status) {
148 const SpoofImpl *This = SpoofImpl::validateThis(sc, *status);
157 uspoof_setAllowedChars(USpoofChecker *sc, const USet *chars, UErrorCode *status) {
159 uspoof_setAllowedUnicodeSet(sc, set, status);
164 uspoof_setAllowedUnicodeSet(USpoofChecker *sc, const UnicodeSet *chars, UErrorCode *status) {
165 SpoofImpl *This = SpoofImpl::validateThis(sc, *status);
170 *status = U_ILLEGAL_ARGUMENT_ERROR;
175 *status = U_MEMORY_ALLOCATION_ERROR;
189 UErrorCode *status) {
191 const SpoofImpl *This = SpoofImpl::validateThis(sc, *status);
196 *status = U_ILLEGAL_ARGUMENT_ERROR;
215 scriptCount = This->scriptScan(text, length, failPos, *status);
241 NFDBuffer normalizedInput(text, length, *status);
305 scriptCount = This->scriptScan(text, length, t, *status);
309 This->wholeScriptCheck(nfdText, nfdLength, &scripts, *status);
337 UErrorCode *status) {
339 if (U_FAILURE(*status)) {
346 u_strFromUTF8(text16, USPOOF_STACK_BUFFER_SIZE, &len16, text, length, status);
347 if (U_FAILURE(*status) && *status != U_BUFFER_OVERFLOW_ERROR) {
350 if (*status == U_BUFFER_OVERFLOW_ERROR) {
353 *status = U_MEMORY_ALLOCATION_ERROR;
356 *status = U_ZERO_ERROR;
357 u_strFromUTF8(text16, len16+1, NULL, text, length, status);
361 int32_t result = uspoof_check(sc, text16, len16, &position16, status);
362 if (U_FAILURE(*status)) {
370 u_strToUTF8(NULL, 0, position, text16, position16, status);
376 *status = U_ZERO_ERROR; // u_strToUTF8, above sets BUFFER_OVERFLOW_ERROR.
390 UChar *dest, int32_t destCapacity, int32_t *outputLength, UErrorCode *status) {
394 if (U_FAILURE(*status)) {
397 requiredCapacity = uspoof_getSkeleton(sc, type, s, inputLength, dest, destCapacity, status);
398 if (*status == U_BUFFER_OVERFLOW_ERROR) {
401 *status = U_MEMORY_ALLOCATION_ERROR;
404 *status = U_ZERO_ERROR;
405 uspoof_getSkeleton(sc, type, s, inputLength, buf, requiredCapacity, status);
416 UErrorCode *status) {
417 const SpoofImpl *This = SpoofImpl::validateThis(sc, *status);
418 if (U_FAILURE(*status)) {
431 *status = U_INVALID_STATE_ERROR;
445 int32_t s1ScriptCount = This->scriptScan(s1, length1, t, *status);
446 int32_t s2ScriptCount = This->scriptScan(s2, length2, t, *status);
453 sizeof(s1SkeletonBuf)/sizeof(UChar), &s1SkeletonLength, status);
455 sizeof(s2SkeletonBuf)/sizeof(UChar), &s2SkeletonLength, status);
489 sizeof(s1SkeletonBuf)/sizeof(UChar), &s1SkeletonLength, status);
491 sizeof(s2SkeletonBuf)/sizeof(UChar), &s2SkeletonLength, status);
515 const char *in, int32_t inLength, UErrorCode *status) {
516 if (U_FAILURE(*status)) {
520 u_strFromUTF8(dest, outBufCapacity, outputLength, in, inLength, status);
521 if (*status == U_BUFFER_OVERFLOW_ERROR) {
524 *status = U_MEMORY_ALLOCATION_ERROR;
527 *status = U_ZERO_ERROR;
528 u_strFromUTF8(dest, *outputLength, NULL, in, inLength, status);
539 UErrorCode *status) {
541 SpoofImpl::validateThis(sc, *status);
542 if (U_FAILURE(*status)) {
548 UChar *s1U = convertFromUTF8(s1Buf, USPOOF_STACK_BUFFER_SIZE, &lengthS1U, s1, length1, status);
552 UChar *s2U = convertFromUTF8(s2Buf, USPOOF_STACK_BUFFER_SIZE, &lengthS2U, s2, length2, status);
554 int32_t results = uspoof_areConfusable(sc, s1U, lengthS1U, s2U, lengthS2U, status);
570 UErrorCode *status) {
577 int32_t results = uspoof_areConfusable(sc, u1, length1, u2, length2, status);
588 UErrorCode *status) {
589 int32_t result = uspoof_check(sc, text.getBuffer(), text.length(), position, status);
599 UErrorCode *status) {
607 const SpoofImpl *This = SpoofImpl::validateThis(sc, *status);
608 if (U_FAILURE(*status)) {
613 *status = U_ILLEGAL_ARGUMENT_ERROR;
632 *status = U_ILLEGAL_ARGUMENT_ERROR;
641 s, length, UNORM_NFD, 0, nfdInput, USPOOF_STACK_BUFFER_SIZE, status);
642 if (*status == U_BUFFER_OVERFLOW_ERROR) {
645 *status = U_MEMORY_ALLOCATION_ERROR;
648 *status = U_ZERO_ERROR;
650 nfdInput, normalizedLen+1, status);
652 if (U_FAILURE(*status)) {
683 if (!unorm_isNormalized(result, resultLen, UNORM_NFD, status)) {
684 normalizedLen = unorm_normalize(result, resultLen, UNORM_NFD, 0, NULL, 0, status);
687 *status = U_MEMORY_ALLOCATION_ERROR;
690 *status = U_ZERO_ERROR;
691 unorm_normalize(result, resultLen, UNORM_NFD, 0, normedResult, normalizedLen+1, status);
697 if (U_SUCCESS(*status)) {
699 *status = resultLen>destCapacity ? U_BUFFER_OVERFLOW_ERROR : U_STRING_NOT_TERMINATED_WARNING;
705 *status = U_STRING_NOT_TERMINATED_WARNING;
720 UErrorCode *status) {
721 if (U_FAILURE(*status)) {
730 int32_t outputSize = uspoof_getSkeleton(sc, type, str, strLen, smallBuf, USPOOF_STACK_BUFFER_SIZE, status);
731 if (*status == U_BUFFER_OVERFLOW_ERROR) {
734 *status = U_MEMORY_ALLOCATION_ERROR;
737 *status = U_ZERO_ERROR;
738 uspoof_getSkeleton(sc, type, str, strLen, buf, outputSize+1, status);
740 if (U_SUCCESS(*status)) {
756 UErrorCode *status) {
760 if (U_FAILURE(*status)) {
774 s, length, status);
775 if (*status == U_BUFFER_OVERFLOW_ERROR) {
778 *status = U_MEMORY_ALLOCATION_ERROR;
781 *status = U_ZERO_ERROR;
783 s, length, status);
787 outBuf, USPOOF_STACK_BUFFER_SIZE, status);
788 if (*status == U_BUFFER_OVERFLOW_ERROR) {
791 *status = U_MEMORY_ALLOCATION_ERROR;
794 *status = U_ZERO_ERROR;
796 outBuf, skelLengthInUChars+1, status);
800 outBuf, skelLengthInUChars, status);
814 uspoof_serialize(USpoofChecker *sc,void *buf, int32_t capacity, UErrorCode *status) {
815 SpoofImpl *This = SpoofImpl::validateThis(sc, *status);
817 U_ASSERT(U_FAILURE(*status));
822 *status = U_BUFFER_OVERFLOW_ERROR;
