Lines Matching refs:source
218 * its source string.
261 * its source string.
265 inline UBool collIter_bos(collIterate *source) {
268 if(source->flags & UCOL_USE_ITERATOR || source->origFlags & UCOL_USE_ITERATOR) {
269 return !source->iterator->hasPrevious(source->iterator);
271 if (source->pos <= source->string ||
272 ((source->flags & UCOL_ITER_INNORMBUF) &&
273 *(source->pos - 1) == 0 && source->fcdPosition == NULL)) {
280 inline UBool collIter_SimpleBos(collIterate *source) {
283 if(source->flags & UCOL_USE_ITERATOR || source->origFlags & UCOL_USE_ITERATOR) {
284 return !source->iterator->hasPrevious(source->iterator);
286 if (source->pos == source->string) {
1373 // The source string is null terminated and we're not working from the side buffer,
1389 // Ran off of the end of the main source string. We're done.
1464 // We are at the last char of source string.
1469 // Not at last char of source string (or we'll check against terminating null). Do the FCD fast test
1749 UChar peekCharacter(collIterate *source, int32_t offset) {
1750 if(source->pos != NULL) {
1751 return *(source->pos + offset);
1752 } else if(source->iterator != NULL) {
1754 source->iterator->move(source->iterator, offset, UITER_CURRENT);
1755 UChar toReturn = (UChar)source->iterator->next(source->iterator);
1756 source->iterator->move(source->iterator, -offset-1, UITER_CURRENT);
1759 return (UChar)source->iterator->current(source->iterator);
1857 /* End of the main source string */
2112 * This normalization sequence will place the current character at source->pos
2324 * @param source data string source
2329 inline void setDiscontiguosAttribute(collIterate *source, UChar *buffer,
2342 if (source->flags & UCOL_ITER_INNORMBUF) {
2343 u_strcpy(tempdb, source->pos);
2346 source->fcdPosition = source->pos;
2347 source->origFlags = source->flags;
2348 source->flags |= UCOL_ITER_INNORMBUF;
2349 source->flags &= ~(UCOL_ITER_NORM | UCOL_ITER_HASLEN | UCOL_USE_ITERATOR);
2352 if (length >= source->writableBufSize) {
2353 freeHeapWritableBuffer(source);
2354 source->writableBuffer =
2356 if(source->writableBuffer == NULL) {
2357 source->writableBufSize = 0; // Reset size
2360 source->writableBufSize = length;
2363 u_strcpy(source->writableBuffer, buffer);
2364 source->pos = source->writableBuffer;
2368 * Function to get the discontiguos collation element within the source.
2371 * @param source data string source
2376 uint32_t getDiscontiguous(const UCollator *coll, collIterate *source,
2379 /* source->pos currently points to the second combining character after
2381 UChar *temppos = source->pos;
2385 uint8_t tempflags = source->flags;
2390 backupState(source, &discState);
2392 //*tempdb = *(source->pos - 1);
2393 *tempdb = peekCharacter(source, -1);
2401 if (((source->flags & UCOL_ITER_HASLEN) && source->pos >= source->endp)
2402 || (peekCharacter(source, 0) == 0 &&
2403 //|| (*source->pos == 0 &&
2404 ((source->flags & UCOL_ITER_INNORMBUF) == 0 ||
2405 source->fcdPosition == NULL ||
2406 source->fcdPosition == source->endp ||
2407 *(source->fcdPosition) == 0 ||
2408 u_getCombiningClass(*(source->fcdPosition)) == 0)) ||
2412 u_getCombiningClass(peekCharacter(source, 0)) == 0) {
2413 //u_getCombiningClass(*(source->pos)) == 0) {
2417 source->pos = temppos - 1;
2418 setDiscontiguosAttribute(source, buffer, tempdb);
2427 schar = getNextNormalizedChar(source);
2442 u_getCombiningClass(peekCharacter(source, -2))) {
2443 //u_getCombiningClass(*(source->pos - 2))) {
2461 temppos = source->pos + 1;
2465 setDiscontiguosAttribute(source, buffer, tempdb);
2477 loadState(source, &discState, TRUE);
2478 goBackOne(source);
2480 //source->pos = temppos - 1;
2481 source->flags = tempflags;
2548 * This normalization sequence will place the current character at source->pos
2723 uint32_t ucol_prv_getSpecialCE(const UCollator *coll, UChar ch, uint32_t CE, collIterate *source, UErrorCode *status) {
2725 backupState(source, &entryState);
2750 backupState(source, &prefixState);
2751 loadState(source, &entryState, TRUE);
2752 goBackOne(source); // We want to look at the point where we entered - actually one
2756 // This loop will run once per source string character, for as long as we
2761 if (collIter_bos(source)) {
2765 schar = getPrevNormalizedChar(source, status);
2766 goBackOne(source);
2773 // Found the source string char in the table.
2780 // Source string char was not in the table.
2787 // The source string char was in the contraction table, and the corresponding
2790 // way out of prefix handling when the source actually contained
2796 loadState(source, &prefixState, TRUE);
2797 if(source->origFlags & UCOL_USE_ITERATOR) {
2798 source->flags = source->origFlags;
2801 loadState(source, &entryState, TRUE);
2809 backupState(source, &state);
2815 /* This loop will run once per source string character, for as long as we */
2821 if (collIter_eos(source)) {
2822 // Ran off the end of the source string.
2826 // back up the source over all the chars we scanned going into this contraction.
2828 loadState(source, &state, TRUE);
2829 if(source->origFlags & UCOL_USE_ITERATOR) {
2830 source->flags = source->origFlags;
2839 schar = getNextNormalizedChar(source);
2845 // Found the source string char in the contraction table.
2852 // Source string char was not in contraction table.
2862 if (source->iterator) {
2864 int32_t prevPos; /* holds the previous position before move forward of the source iterator */
2865 if(U16_IS_LEAD(schar) && source->iterator->hasNext(source->iterator)) {
2866 prevPos = source->iterator->index;
2867 surrNextChar = getNextNormalizedChar(source);
2870 } else if (prevPos < source->iterator->index){
2871 goBackOne(source);
2875 miss = U16_GET_SUPPLEMENTARY(schar, getNextNormalizedChar(source));
2884 collIter_eos(source))
2887 goBackOne(source); // back up the source string by one,
2891 goBackOne(source);
2898 // Scan more of source string looking for a match
2903 tempchar = getNextNormalizedChar(source);
2905 goBackOne(source);
2907 goBackOne(source);
2909 goBackOne(source);
2915 CE = getDiscontiguous(coll, source, ContractionStart);
2921 /* The Source string did not match the contraction that we were checking. */
2922 /* Back up the source position to undo the effects of having partially */
2924 loadState(source, &state, TRUE);
2930 // The source string char was in the contraction table, and the corresponding
2933 // way out of contraction handling when the source actually contained
2939 // The source string char was in the contraction table, and the corresponding
2940 // CE is IS a contraction CE. We will continue looping to check the source
2944 // We have scanned a a section of source string for which there is a
2950 goBackOne(source);
2951 backupState(source, &state);
2952 getNextNormalizedChar(source);
2956 //backupState(source, &tempState);
2957 //goBackOne(source);
2958 //backupState(source, &state);
2959 //loadState(source, &tempState, TRUE);
2972 *(source->CEpos++) = ((CE & 0xFF)<<24)|UCOL_CONTINUATION_MARKER;
2974 source->offsetRepeatCount += 1;
2988 //source->offsetRepeatCount = -1;
2992 *(source->CEpos++) = *CEOffset++;
2993 source->offsetRepeatCount += 1;
2997 *(source->CEpos++) = *CEOffset++;
2998 source->offsetRepeatCount += 1;
3013 if (source->coll->numericCollation == UCOL_ON){
3028 We parse the source string until we hit a char that's NOT a digit.
3034 if (!collIter_eos(source)) {
3035 backupState(source, &digitState);
3036 UChar trail = getNextNormalizedChar(source);
3040 loadState(source, &digitState, TRUE);
3113 if (!collIter_eos(source)){
3114 ch = getNextNormalizedChar(source);
3116 if (!collIter_eos(source)) {
3117 backupState(source, &digitState);
3118 UChar trail = getNextNormalizedChar(source);
3122 loadState(source, &digitState, TRUE);
3134 loadState(source, &digitState, TRUE);
3135 //goBackOne(source);
3137 goBackOne(source);
3189 *(source->CEpos++) = (primWeight << UCOL_PRIMARYORDERSHIFT) | UCOL_CONTINUATION_MARKER;
3203 return getImplicit(cp, source);
3206 return getImplicit(cp, source);
3232 if (!source->coll->image->jamoSpecial) { // FAST PATH
3234 *(source->CEpos++) = UTRIE_GET32_FROM_LEAD(&coll->mapping, V);
3236 *(source->CEpos++) = UTRIE_GET32_FROM_LEAD(&coll->mapping, T);
3249 if(source->iterator != NULL && source->flags & UCOL_ITER_INNORMBUF) {
3250 source->flags = source->origFlags; // restore the iterator
3251 source->pos = NULL;
3254 source->writableBuffer[0] = (UChar)L;
3255 source->writableBuffer[1] = (UChar)V;
3257 source->writableBuffer[2] = (UChar)T;
3258 source->writableBuffer[3] = 0;
3260 source->writableBuffer[2] = 0;
3263 source->fcdPosition = source->pos; // Indicate where to continue in main input string
3265 source->pos = source->writableBuffer;
3266 source->origFlags = source->flags;
3267 source->flags |= UCOL_ITER_INNORMBUF;
3268 source->flags &= ~(UCOL_ITER_NORM | UCOL_ITER_HASLEN);
3281 backupState(source, &state);
3282 if (collIter_eos(source) || !(U16_IS_TRAIL((trail = getNextNormalizedChar(source))))) {
3285 loadState(source, &state, TRUE);
3292 loadState(source, &state, TRUE);
3302 if( source->flags & UCOL_USE_ITERATOR) {
3303 if(U_IS_TRAIL(nextChar = (UChar)source->iterator->current(source->iterator))) {
3305 source->iterator->next(source->iterator);
3306 return getImplicit(cp, source);
3310 } else if((((source->flags & UCOL_ITER_HASLEN) == 0 ) || (source->pos<source->endp)) &&
3311 U_IS_TRAIL((nextChar=*source->pos))) {
3313 source->pos++;
3314 return getImplicit(cp, source);
3378 collIterate *source,
3411 backupState(source, &prefixState);
3413 // This loop will run once per source string character, for as long as we
3419 if (collIter_bos(source)) {
3423 schar = getPrevNormalizedChar(source, status);
3424 goBackOne(source);
3431 // Found the source string char in the table.
3453 if (!collIter_bos(source)) {
3455 if(U16_IS_LEAD(lead = getPrevNormalizedChar(source, status))) {
3461 goBackOne(source);
3474 // Source string char was not in the table.
3481 // The source string char was in the contraction table, and the corresponding
3484 // way out of prefix handling when the source actually contained
3489 loadState(source, &prefixState, TRUE);
3499 schar = peekCharacter(source, 0);
3501 if (isAtStartPrevIterate(source)
3518 schar = getPrevNormalizedChar(source, status);
3519 goBackOne(source);
3529 if(source->pos) { // actually dealing with a position
3530 newsize = source->pos - source->string + 1;
3546 if ((source->pos && (source->pos == source->string ||
3547 ((source->flags & UCOL_ITER_INNORMBUF) &&
3548 *(source->pos - 1) == 0 && source->fcdPosition == NULL)))
3549 || (source->iterator && !source->iterator->hasPrevious(source->iterator))) {
3560 if (source->flags & UCOL_ITER_INNORMBUF) {
3563 offsetBias = (int32_t)(source->pos - source->string);
3574 temp.flags |= source->flags & UCOL_FORCE_HAN_IMPLICIT;
3579 if (source->extendCEs) {
3580 endCEBuffer = source->extendCEs + source->extendCEsSize;
3581 CECount = (source->CEpos - source->extendCEs)/sizeof(uint32_t);
3583 endCEBuffer = source->CEs + UCOL_EXPAND_CE_BUFFER_SIZE;
3584 CECount = (source->CEpos - source->CEs)/sizeof(uint32_t);
3587 if (source->offsetBuffer == NULL) {
3588 source->offsetBufferSize = UCOL_EXPAND_CE_BUFFER_SIZE;
3589 source->offsetBuffer = (int32_t *) uprv_malloc(sizeof(int32_t) * UCOL_EXPAND_CE_BUFFER_SIZE);
3590 source->offsetStore = source->offsetBuffer;
3594 *(source->CEpos ++) = CE;
3597 *(source->offsetStore ++) = rawOffset + offsetBias;
3601 if (source->CEpos == endCEBuffer) {
3606 if (source->extendCEs == NULL) {
3607 source->extendCEs = (uint32_t *)uprv_malloc(sizeof(uint32_t) *
3608 (source->extendCEsSize =UCOL_EXPAND_CE_BUFFER_SIZE + UCOL_EXPAND_CE_BUFFER_EXTEND_SIZE));
3609 if (source->extendCEs == NULL) {
3613 source->extendCEs = (uint32_t *)uprv_memcpy(source->extendCEs, source->CEs, UCOL_EXPAND_CE_BUFFER_SIZE * sizeof(uint32_t));
3616 uint32_t *tempBufCE = (uint32_t *)uprv_realloc(source->extendCEs,
3617 sizeof(uint32_t) * (source->extendCEsSize += UCOL_EXPAND_CE_BUFFER_EXTEND_SIZE));
3623 source->extendCEs = tempBufCE;
3629 source->extendCEsSize = 0;
3630 source->CEpos = source->CEs;
3640 source->CEpos = source->extendCEs + CECount;
3641 endCEBuffer = source->extendCEs + source->extendCEsSize;
3644 if (offsetBias >= 0 && source->offsetStore >= &source->offsetBuffer[source->offsetBufferSize]) {
3645 int32_t storeIX = source->offsetStore - source->offsetBuffer;
3646 int32_t *tob = (int32_t *) uprv_realloc(source->offsetBuffer,
3647 sizeof(int32_t) * (source->offsetBufferSize + UCOL_EXPAND_CE_BUFFER_EXTEND_SIZE));
3650 source->offsetBuffer = tob;
3651 source->offsetStore = &source->offsetBuffer[storeIX];
3652 source->offsetBufferSize += UCOL_EXPAND_CE_BUFFER_EXTEND_SIZE;
3656 source->CEpos = source->CEs;
3676 if (source->offsetRepeatValue != 0) {
3678 source->offsetRepeatCount += temp.offsetRepeatCount;
3681 source->offsetReturn -= (noChars - CECount);
3692 source->offsetReturn = source->offsetStore - 1;
3693 if (source->offsetReturn == source->offsetBuffer) {
3694 source->offsetStore = source->offsetBuffer;
3698 source->toReturn = source->CEpos - 1;
3699 if (source->toReturn == source->CEs) {
3700 source->CEpos = source->CEs;
3703 return *(source->toReturn);
3707 source->CEpos++) = ((CE & 0xFFFF00) << 8) | (UCOL_BYTE_COMMON << 8) | UCOL_BYTE_COMMON;
3708 *(source->CEpos++) = ((CE & 0xFF)<<24)|UCOL_CONTINUATION_MARKER;
3709 source->toReturn = source->CEpos - 1;
3711 if (source->offsetBuffer == NULL) {
3712 source->offsetBufferSize = UCOL_EXPAND_CE_BUFFER_SIZE;
3713 source->offsetBuffer = (int32_t *) uprv_malloc(sizeof(int32_t) * UCOL_EXPAND_CE_BUFFER_SIZE);
3714 source->offsetStore = source->offsetBuffer;
3717 if (source->flags & UCOL_ITER_INNORMBUF) {
3718 source->offsetRepeatCount = 1;
3720 int32_t firstOffset = (int32_t)(source->pos - source->string);
3722 *(source->offsetStore++) = firstOffset;
3723 *(source->offsetStore++) = firstOffset + 1;
3725 source->offsetReturn = source->offsetStore - 1;
3726 *(source->offsetBuffer) = firstOffset;
3727 if (source->offsetReturn == source->offsetBuffer) {
3728 source->offsetStore = source->offsetBuffer;
3733 return *(source->toReturn);
3743 int32_t firstOffset = (int32_t)(source->pos - source->string);
3746 if (source->offsetReturn != NULL) {
3747 if (! (source->flags & UCOL_ITER_INNORMBUF) && source->offsetReturn == source->offsetBuffer) {
3748 source->offsetStore = source->offsetBuffer;
3754 if (source->offsetBuffer == NULL) {
3755 source->offsetBufferSize = UCOL_EXPAND_CE_BUFFER_SIZE;
3756 source->offsetBuffer = (int32_t *) uprv_malloc(sizeof(int32_t) * UCOL_EXPAND_CE_BUFFER_SIZE);
3757 source->offsetStore = source->offsetBuffer;
3770 *(source->CEpos ++) = *CEOffset++;
3773 *(source->offsetStore ++) = firstOffset + 1;
3779 *(source->CEpos ++) = *CEOffset ++;
3782 *(source->offsetStore ++) = firstOffset + 1;
3788 source->offsetReturn = source->offsetStore - 1;
3789 *(source->offsetBuffer) = firstOffset;
3790 if (source->offsetReturn == source->offsetBuffer) {
3791 source->offsetStore = source->offsetBuffer;
3794 source->offsetRepeatCount += size - 1;
3797 source->toReturn = source->CEpos - 1;
3800 if(source->toReturn == source->CEs) {
3801 source->CEpos = source->CEs;
3804 return *(source->toReturn);
3816 if (source->coll->numericCollation == UCOL_ON){
3828 We parse the source string until we hit a char that's NOT a digit.
3844 backupState(source, &initialState);
3852 if (!collIter_bos(source)){
3853 UChar lead = getPrevNormalizedChar(source, status);
3856 goBackOne(source);
3928 if (!collIter_bos(source)) {
3929 ch = getPrevNormalizedChar(source, status);
3930 //goBackOne(source);
3932 backupState(source, &state);
3933 if (!collIter_bos(source)) {
3934 goBackOne(source);
3935 UChar lead = getPrevNormalizedChar(source, status);
3940 loadState(source, &state, FALSE);
3949 loadState(source, &state, FALSE);
3954 //getNextNormalizedChar(source);
3958 goBackOne(source);
3974 loadState(source, &initialState, FALSE);
4018 *(source->CEpos++) = (((numTempBuf[0] << 8) | numTempBuf[1]) << UCOL_PRIMARYORDERSHIFT) | //Primary weight
4026 *(source->CEpos++) = (primWeight << UCOL_PRIMARYORDERSHIFT) | UCOL_CONTINUATION_MARKER;
4029 source->toReturn = source->CEpos -1;
4030 return *(source->toReturn);
4064 if (source->offsetBuffer == NULL) {
4065 source->offsetBufferSize = UCOL_EXPAND_CE_BUFFER_SIZE;
4066 source->offsetBuffer = (int32_t *) uprv_malloc(sizeof(int32_t) * UCOL_EXPAND_CE_BUFFER_SIZE);
4067 source->offsetStore = source->offsetBuffer;
4070 int32_t firstOffset = (int32_t)(source->pos - source->string);
4072 *(source->offsetStore++) = firstOffset;
4077 if (!source->coll->image->jamoSpecial) {
4078 *(source->CEpos++) = UTRIE_GET32_FROM_LEAD(&coll->mapping, L);
4079 *(source->CEpos++) = UTRIE_GET32_FROM_LEAD(&coll->mapping, V);
4080 *(source->offsetStore++) = firstOffset + 1;
4083 *(source->CEpos++) = UTRIE_GET32_FROM_LEAD(&coll->mapping, T);
4084 *(source->offsetStore++) = firstOffset + 1;
4087 source->toReturn = source->CEpos - 1;
4089 source->offsetReturn = source->offsetStore - 1;
4090 if (source->offsetReturn == source->offsetBuffer) {
4091 source->offsetStore = source->offsetBuffer;
4094 return *(source->toReturn);
4104 UChar *tempbuffer = source->writableBuffer +
4105 (source->writableBufSize - 1);
4122 if (source->pos == source->string) {
4123 source->fcdPosition = NULL;
4125 source->fcdPosition = source->pos-1;
4128 source->pos = tempbuffer;
4129 source->origFlags = source->flags;
4130 source->flags |= UCOL_ITER_INNORMBUF;
4131 source->flags &= ~(UCOL_ITER_NORM | UCOL_ITER_HASLEN);
4138 return getPrevImplicit(ch, source);
4142 return getPrevImplicit(ch, source);
4158 if (isAtStartPrevIterate(source)) {
4162 if (source->pos != source->writableBuffer) {
4163 prev = source->pos - 1;
4165 prev = source->fcdPosition;
4172 source->pos = prev;
4177 return getPrevImplicit(cp, source);
4364 const UChar *source,
4371 UTRACE_DATA3(UTRACE_VERBOSE, "coll=%p, source string = %vh ", coll, source,
4372 ((sourceLength==-1 && source!=NULL) ? u_strlen(source) : sourceLength));
4378 if(source != NULL) {
4379 // source == NULL is actually an error situation, but we would need to
4388 keySize = coll->sortKeyGen(coll, source, sourceLength, &result, resultLength, FALSE, &status);
4406 const UChar *source, int32_t sourceLength,
4410 return coll->sortKeyGen(coll, source, sourceLength, pResult, 0, TRUE, pErrorCode);
4762 const UChar *source,
4796 int32_t len = (sourceLength == -1 ? u_strlen(source) : sourceLength);
4839 if(normMode != UNORM_NONE && UNORM_YES != unorm_quickCheck(source, len, normMode, status)) {
4841 source, len,
4853 source, len,
4861 source = normSource;
4865 IInit_collIterate(coll, (UChar *)source, len, &s);
4866 if(source == normSource) {
5143 IInit_collIterate(coll, (UChar *)source, len, &s);
5144 if(source == normSource) {
5422 const UChar *source,
5459 if(coll->normalizationMode != UCOL_OFF && UNORM_YES != unorm_quickCheck(source, len, UNORM_FCD, status)) {
5461 source, len,
5473 source, len,
5486 source = normSource;
5490 IInit_collIterate(coll, (UChar *)source, len, &s);
5491 if(source == normSource) {
5656 IInit_collIterate(coll, (UChar *)source, len, &s);
5657 if(source == normSource) {
6670 ucol_getBound(const uint8_t *source,
6682 if(source == NULL) {
6691 if(source[sourceIndex] == UCOL_LEVELTERMINATOR) {
6695 && (source[sourceIndex] != 0 || sourceIndex < sourceLength));
6697 if((source[sourceIndex] == 0 || sourceIndex == sourceLength)
6708 uprv_memcpy(result, source, sourceIndex);
7542 UChar *source = NULL;
7553 source = sStackBuf;
7554 UChar *sBufp = source;
7563 sourceLength = sBufp - source;
7568 source = sColl->string;
7574 sourceKeyLen = ucol_getSortKey(coll, source, sourceLength, sourceKeyP, sourceKeyLen);
7581 sourceKeyLen = ucol_getSortKey(coll, source, sourceLength, sourceKeyP, sourceKeyLen);
7618 // const UChar *source,
7708 // Source loop. Sam as the target loop.
8161 const UChar *source,
8184 // sOrder=getNextlatinOneCE(source);
8186 sChar=source[sIndex++];
8196 sChar=source[sIndex++];
8201 //return ucol_strcollRegular(coll, source, sLen, target, tLen, status);
8208 sOrder = ucol_getLatinOneContraction(coll, UCOL_PRIMARY, sOrder, source, &sIndex, sLen);
8216 //return ucol_strcollRegular(coll, source, sLen, target, tLen, status);
8226 if(endOfSource) { // this is different than source loop,
8227 // as we already know that source loop is done here,
8249 //return ucol_strcollRegular(coll, source, sLen, target, tLen, status);
8253 // Handling specials, see the comments for source
8261 //return ucol_strcollRegular(coll, source, sLen, target, tLen, status);
8265 if(endOfSource) { // source is finished, but target is not, say the result.
8312 sChar=source[sIndex++];
8315 sOrder = ucol_getLatinOneContraction(coll, UCOL_SECONDARY, sOrder, source, &sIndex, sLen);
8357 //return ucol_strcollRegular(coll, source, sLen, target, tLen, status);
8367 sChar=source[--sIndex];
8419 sChar=source[sIndex++];
8422 sOrder = ucol_getLatinOneContraction(coll, UCOL_TERTIARY, sOrder, source, &sIndex, sLen);
8464 IInit_collIterate(coll, source, sLen, &sColl);
8576 const UChar *source,
8585 UTRACE_DATA3(UTRACE_VERBOSE, "coll=%p, source=%p, target=%p", coll, source, target);
8586 UTRACE_DATA2(UTRACE_VERBOSE, "source string = %vh ", source, sourceLength);
8590 if(source == NULL || target == NULL) {
8597 /* Quick check if source and target are same strings. */
8599 if (source==target && sourceLength==targetLength) {
8607 const UChar *pSrc = source;
8622 equalLength = pSrc - source;
8627 const UChar *pSrcEnd = source + sourceLength;
8644 equalLength = pSrc - source;
8660 //pSrc = source + equalLength; /* point to the first differing chars */
8662 if (pSrc != source+sourceLength && ucol_unsafeCP(*pSrc, coll) ||
8676 source += equalLength;
8688 if(!coll->latinOneUse || (sourceLength > 0 && *source&0xff00) || (targetLength > 0 && *target&0xff00)) {
8691 IInit_collIterate(coll, source, sourceLength, &sColl);
8695 returnVal = ucol_strcollUseLatin1(coll, source, sourceLength, target, targetLength, &status);
8704 const UChar *source,
8709 return (ucol_strcoll(coll, source, sourceLength, target, targetLength)
8716 const UChar *source,
8721 return (ucol_strcoll(coll, source, sourceLength, target, targetLength)
8728 const UChar *source,
8733 return (ucol_strcoll(coll, source, sourceLength, target, targetLength)
