[apple/icu.git] / icuSources / i18n / collationcompare.cpp

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
* Copyright (C) 1996-2015, International Business Machines
* Corporation and others.  All Rights Reserved.
*******************************************************************************
* collationcompare.cpp
*
* created on: 2012feb14 with new and old collation code
* created by: Markus W. Scherer
*/

#include "unicode/utypes.h"

#if !UCONFIG_NO_COLLATION

#include "unicode/ucol.h"
#include "cmemory.h"
#include "collation.h"
#include "collationcompare.h"
#include "collationiterator.h"
#include "collationsettings.h"
#include "uassert.h"

U_NAMESPACE_BEGIN

UCollationResult
CollationCompare::compareUpToQuaternary(CollationIterator &left, CollationIterator &right,
                                        const CollationSettings &settings,
                                        UErrorCode &errorCode) {
    if(U_FAILURE(errorCode)) { return UCOL_EQUAL; }

    int32_t options = settings.options;
    uint32_t variableTop;
    if((options & CollationSettings::ALTERNATE_MASK) == 0) {
        variableTop = 0;
    } else {
        // +1 so that we can use "<" and primary ignorables test out early.
        variableTop = settings.variableTop + 1;
    }
    UBool anyVariable = FALSE;

    // Fetch CEs, compare primaries, store secondary & tertiary weights.
    for(;;) {
        // We fetch CEs until we get a non-ignorable primary or reach the end.
        uint32_t leftPrimary;
        do {
            int64_t ce = left.nextCE(errorCode);
            leftPrimary = (uint32_t)(ce >> 32);
            if(leftPrimary < variableTop && leftPrimary > Collation::MERGE_SEPARATOR_PRIMARY) {
                // Variable CE, shift it to quaternary level.
                // Ignore all following primary ignorables, and shift further variable CEs.
                anyVariable = TRUE;
                do {
                    // Store only the primary of the variable CE.
                    left.setCurrentCE(ce & INT64_C(0xffffffff00000000));
                    for(;;) {
                        ce = left.nextCE(errorCode);
                        leftPrimary = (uint32_t)(ce >> 32);
                        if(leftPrimary == 0) {
                            left.setCurrentCE(0);
                        } else {
                            break;
                        }
                    }
                } while(leftPrimary < variableTop &&
                        leftPrimary > Collation::MERGE_SEPARATOR_PRIMARY);
            }
        } while(leftPrimary == 0);

        uint32_t rightPrimary;
        do {
            int64_t ce = right.nextCE(errorCode);
            rightPrimary = (uint32_t)(ce >> 32);
            if(rightPrimary < variableTop && rightPrimary > Collation::MERGE_SEPARATOR_PRIMARY) {
                // Variable CE, shift it to quaternary level.
                // Ignore all following primary ignorables, and shift further variable CEs.
                anyVariable = TRUE;
                do {
                    // Store only the primary of the variable CE.
                    right.setCurrentCE(ce & INT64_C(0xffffffff00000000));
                    for(;;) {
                        ce = right.nextCE(errorCode);
                        rightPrimary = (uint32_t)(ce >> 32);
                        if(rightPrimary == 0) {
                            right.setCurrentCE(0);
                        } else {
                            break;
                        }
                    }
                } while(rightPrimary < variableTop &&
                        rightPrimary > Collation::MERGE_SEPARATOR_PRIMARY);
            }
        } while(rightPrimary == 0);

        if(leftPrimary != rightPrimary) {
            // Return the primary difference, with script reordering.
            if(settings.hasReordering()) {
                leftPrimary = settings.reorder(leftPrimary);
                rightPrimary = settings.reorder(rightPrimary);
            }
            return (leftPrimary < rightPrimary) ? UCOL_LESS : UCOL_GREATER;
        }
        if(leftPrimary == Collation::NO_CE_PRIMARY) { break; }
    }
    if(U_FAILURE(errorCode)) { return UCOL_EQUAL; }

    // Compare the buffered secondary & tertiary weights.
    // We might skip the secondary level but continue with the case level
    // which is turned on separately.
    if(CollationSettings::getStrength(options) >= UCOL_SECONDARY) {
        if((options & CollationSettings::BACKWARD_SECONDARY) == 0) {
            int32_t leftIndex = 0;
            int32_t rightIndex = 0;
            for(;;) {
                uint32_t leftSecondary;
                do {
                    leftSecondary = ((uint32_t)left.getCE(leftIndex++)) >> 16;
                } while(leftSecondary == 0);

                uint32_t rightSecondary;
                do {
                    rightSecondary = ((uint32_t)right.getCE(rightIndex++)) >> 16;
                } while(rightSecondary == 0);

                if(leftSecondary != rightSecondary) {
                    return (leftSecondary < rightSecondary) ? UCOL_LESS : UCOL_GREATER;
                }
                if(leftSecondary == Collation::NO_CE_WEIGHT16) { break; }
            }
        } else {
            // The backwards secondary level compares secondary weights backwards
            // within segments separated by the merge separator (U+FFFE, weight 02).
            int32_t leftStart = 0;
            int32_t rightStart = 0;
            for(;;) {
                // Find the merge separator or the NO_CE terminator.
                uint32_t p;
                int32_t leftLimit = leftStart;
                while((p = (uint32_t)(left.getCE(leftLimit) >> 32)) >
                            Collation::MERGE_SEPARATOR_PRIMARY ||
                        p == 0) {
                    ++leftLimit;
                }
                int32_t rightLimit = rightStart;
                while((p = (uint32_t)(right.getCE(rightLimit) >> 32)) >
                            Collation::MERGE_SEPARATOR_PRIMARY ||
                        p == 0) {
                    ++rightLimit;
                }

                // Compare the segments.
                int32_t leftIndex = leftLimit;
                int32_t rightIndex = rightLimit;
                for(;;) {
                    int32_t leftSecondary = 0;
                    while(leftSecondary == 0 && leftIndex > leftStart) {
                        leftSecondary = ((uint32_t)left.getCE(--leftIndex)) >> 16;
                    }

                    int32_t rightSecondary = 0;
                    while(rightSecondary == 0 && rightIndex > rightStart) {
                        rightSecondary = ((uint32_t)right.getCE(--rightIndex)) >> 16;
                    }

                    if(leftSecondary != rightSecondary) {
                        return (leftSecondary < rightSecondary) ? UCOL_LESS : UCOL_GREATER;
                    }
                    if(leftSecondary == 0) { break; }
                }

                // Did we reach the end of either string?
                // Both strings have the same number of merge separators,
                // or else there would have been a primary-level difference.
                U_ASSERT(left.getCE(leftLimit) == right.getCE(rightLimit));
                if(p == Collation::NO_CE_PRIMARY) { break; }
                // Skip both merge separators and continue.
                leftStart = leftLimit + 1;
                rightStart = rightLimit + 1;
            }
        }
    }

    if((options & CollationSettings::CASE_LEVEL) != 0) {
        int32_t strength = CollationSettings::getStrength(options);
        int32_t leftIndex = 0;
        int32_t rightIndex = 0;
        for(;;) {
            uint32_t leftCase, leftLower32, rightCase;
            if(strength == UCOL_PRIMARY) {
                // Primary+caseLevel: Ignore case level weights of primary ignorables.
                // Otherwise we would get a-umlaut > a
                // which is not desirable for accent-insensitive sorting.
                // Check for (lower 32 bits) == 0 as well because variable CEs are stored
                // with only primary weights.
                int64_t ce;
                do {
                    ce = left.getCE(leftIndex++);
                    leftCase = (uint32_t)ce;
                } while((uint32_t)(ce >> 32) == 0 || leftCase == 0);
                leftLower32 = leftCase;
                leftCase &= 0xc000;

                do {
                    ce = right.getCE(rightIndex++);
                    rightCase = (uint32_t)ce;
                } while((uint32_t)(ce >> 32) == 0 || rightCase == 0);
                rightCase &= 0xc000;
            } else {
                // Secondary+caseLevel: By analogy with the above,
                // ignore case level weights of secondary ignorables.
                //
                // Note: A tertiary CE has uppercase case bits (0.0.ut)
                // to keep tertiary+caseFirst well-formed.
                //
                // Tertiary+caseLevel: Also ignore case level weights of secondary ignorables.
                // Otherwise a tertiary CE's uppercase would be no greater than
                // a primary/secondary CE's uppercase.
                // (See UCA well-formedness condition 2.)
                // We could construct a special case weight higher than uppercase,
                // but it's simpler to always ignore case weights of secondary ignorables,
                // turning 0.0.ut into 0.0.0.t.
                // (See LDML Collation, Case Parameters.)
                do {
                    leftCase = (uint32_t)left.getCE(leftIndex++);
                } while(leftCase <= 0xffff);
                leftLower32 = leftCase;
                leftCase &= 0xc000;

                do {
                    rightCase = (uint32_t)right.getCE(rightIndex++);
                } while(rightCase <= 0xffff);
                rightCase &= 0xc000;
            }

            // No need to handle NO_CE and MERGE_SEPARATOR specially:
            // There is one case weight for each previous-level weight,
            // so level length differences were handled there.
            if(leftCase != rightCase) {
                if((options & CollationSettings::UPPER_FIRST) == 0) {
                    return (leftCase < rightCase) ? UCOL_LESS : UCOL_GREATER;
                } else {
                    return (leftCase < rightCase) ? UCOL_GREATER : UCOL_LESS;
                }
            }
            if((leftLower32 >> 16) == Collation::NO_CE_WEIGHT16) { break; }
        }
    }
    if(CollationSettings::getStrength(options) <= UCOL_SECONDARY) { return UCOL_EQUAL; }

    uint32_t tertiaryMask = CollationSettings::getTertiaryMask(options);

    int32_t leftIndex = 0;
    int32_t rightIndex = 0;
    uint32_t anyQuaternaries = 0;
    for(;;) {
        uint32_t leftLower32, leftTertiary;
        do {
            leftLower32 = (uint32_t)left.getCE(leftIndex++);
            anyQuaternaries |= leftLower32;
            U_ASSERT((leftLower32 & Collation::ONLY_TERTIARY_MASK) != 0 ||
                     (leftLower32 & 0xc0c0) == 0);
            leftTertiary = leftLower32 & tertiaryMask;
        } while(leftTertiary == 0);

        uint32_t rightLower32, rightTertiary;
        do {
            rightLower32 = (uint32_t)right.getCE(rightIndex++);
            anyQuaternaries |= rightLower32;
            U_ASSERT((rightLower32 & Collation::ONLY_TERTIARY_MASK) != 0 ||
                     (rightLower32 & 0xc0c0) == 0);
            rightTertiary = rightLower32 & tertiaryMask;
        } while(rightTertiary == 0);

        if(leftTertiary != rightTertiary) {
            if(CollationSettings::sortsTertiaryUpperCaseFirst(options)) {
                // Pass through NO_CE and keep real tertiary weights larger than that.
                // Do not change the artificial uppercase weight of a tertiary CE (0.0.ut),
                // to keep tertiary CEs well-formed.
                // Their case+tertiary weights must be greater than those of
                // primary and secondary CEs.
                if(leftTertiary > Collation::NO_CE_WEIGHT16) {
                    if(leftLower32 > 0xffff) {
                        leftTertiary ^= 0xc000;
                    } else {
                        leftTertiary += 0x4000;
                    }
                }
                if(rightTertiary > Collation::NO_CE_WEIGHT16) {
                    if(rightLower32 > 0xffff) {
                        rightTertiary ^= 0xc000;
                    } else {
                        rightTertiary += 0x4000;
                    }
                }
            }
            return (leftTertiary < rightTertiary) ? UCOL_LESS : UCOL_GREATER;
        }
        if(leftTertiary == Collation::NO_CE_WEIGHT16) { break; }
    }
    if(CollationSettings::getStrength(options) <= UCOL_TERTIARY) { return UCOL_EQUAL; }

    if(!anyVariable && (anyQuaternaries & 0xc0) == 0) {
        // If there are no "variable" CEs and no non-zero quaternary weights,
        // then there are no quaternary differences.
        return UCOL_EQUAL;
    }

    leftIndex = 0;
    rightIndex = 0;
    for(;;) {
        uint32_t leftQuaternary;
        do {
            int64_t ce = left.getCE(leftIndex++);
            leftQuaternary = (uint32_t)ce & 0xffff;
            if(leftQuaternary <= Collation::NO_CE_WEIGHT16) {
                // Variable primary or completely ignorable or NO_CE.
                leftQuaternary = (uint32_t)(ce >> 32);
            } else {
                // Regular CE, not tertiary ignorable.
                // Preserve the quaternary weight in bits 7..6.
                leftQuaternary |= 0xffffff3f;
            }
        } while(leftQuaternary == 0);

        uint32_t rightQuaternary;
        do {
            int64_t ce = right.getCE(rightIndex++);
            rightQuaternary = (uint32_t)ce & 0xffff;
            if(rightQuaternary <= Collation::NO_CE_WEIGHT16) {
                // Variable primary or completely ignorable or NO_CE.
                rightQuaternary = (uint32_t)(ce >> 32);
            } else {
                // Regular CE, not tertiary ignorable.
                // Preserve the quaternary weight in bits 7..6.
                rightQuaternary |= 0xffffff3f;
            }
        } while(rightQuaternary == 0);

        if(leftQuaternary != rightQuaternary) {
            // Return the difference, with script reordering.
            if(settings.hasReordering()) {
                leftQuaternary = settings.reorder(leftQuaternary);
                rightQuaternary = settings.reorder(rightQuaternary);
            }
            return (leftQuaternary < rightQuaternary) ? UCOL_LESS : UCOL_GREATER;
        }
        if(leftQuaternary == Collation::NO_CE_PRIMARY) { break; }
    }
    return UCOL_EQUAL;
}

U_NAMESPACE_END

#endif  // !UCONFIG_NO_COLLATION
Commit	Line	Data
f3c0d7a5 A	1	// © 2016 and later: Unicode, Inc. and others.
f3c0d7a5 A	2	// License & terms of use: http://www.unicode.org/copyright.html
57a6839d A	3	/*
57a6839d A	4	*******************************************************************************
b331163b	5	* Copyright (C) 1996-2015, International Business Machines
57a6839d A	6	* Corporation and others. All Rights Reserved.
	7	*******************************************************************************
	8	* collationcompare.cpp
	9	*
	10	* created on: 2012feb14 with new and old collation code
	11	* created by: Markus W. Scherer
	12	*/
	13
	14	#include "unicode/utypes.h"
	15
	16	#if !UCONFIG_NO_COLLATION
	17
	18	#include "unicode/ucol.h"
	19	#include "cmemory.h"
	20	#include "collation.h"
	21	#include "collationcompare.h"
	22	#include "collationiterator.h"
	23	#include "collationsettings.h"
	24	#include "uassert.h"
	25
	26	U_NAMESPACE_BEGIN
	27
	28	UCollationResult
	29	CollationCompare::compareUpToQuaternary(CollationIterator &left, CollationIterator &right,
	30	const CollationSettings &settings,
	31	UErrorCode &errorCode) {
	32	if(U_FAILURE(errorCode)) { return UCOL_EQUAL; }
	33
	34	int32_t options = settings.options;
	35	uint32_t variableTop;
	36	if((options & CollationSettings::ALTERNATE_MASK) == 0) {
	37	variableTop = 0;
	38	} else {
	39	// +1 so that we can use "<" and primary ignorables test out early.
	40	variableTop = settings.variableTop + 1;
	41	}
	42	UBool anyVariable = FALSE;
	43
	44	// Fetch CEs, compare primaries, store secondary & tertiary weights.
57a6839d A	45	for(;;) {
	46	// We fetch CEs until we get a non-ignorable primary or reach the end.
	47	uint32_t leftPrimary;
	48	do {
	49	int64_t ce = left.nextCE(errorCode);
	50	leftPrimary = (uint32_t)(ce >> 32);
	51	if(leftPrimary < variableTop && leftPrimary > Collation::MERGE_SEPARATOR_PRIMARY) {
	52	// Variable CE, shift it to quaternary level.
	53	// Ignore all following primary ignorables, and shift further variable CEs.
	54	anyVariable = TRUE;
	55	do {
	56	// Store only the primary of the variable CE.
	57	left.setCurrentCE(ce & INT64_C(0xffffffff00000000));
	58	for(;;) {
	59	ce = left.nextCE(errorCode);
	60	leftPrimary = (uint32_t)(ce >> 32);
	61	if(leftPrimary == 0) {
	62	left.setCurrentCE(0);
	63	} else {
	64	break;
	65	}
	66	}
	67	} while(leftPrimary < variableTop &&
	68	leftPrimary > Collation::MERGE_SEPARATOR_PRIMARY);
	69	}
	70	} while(leftPrimary == 0);
	71
	72	uint32_t rightPrimary;
	73	do {
	74	int64_t ce = right.nextCE(errorCode);
	75	rightPrimary = (uint32_t)(ce >> 32);
	76	if(rightPrimary < variableTop && rightPrimary > Collation::MERGE_SEPARATOR_PRIMARY) {
	77	// Variable CE, shift it to quaternary level.
	78	// Ignore all following primary ignorables, and shift further variable CEs.
	79	anyVariable = TRUE;
	80	do {
	81	// Store only the primary of the variable CE.
	82	right.setCurrentCE(ce & INT64_C(0xffffffff00000000));
	83	for(;;) {
	84	ce = right.nextCE(errorCode);
	85	rightPrimary = (uint32_t)(ce >> 32);
	86	if(rightPrimary == 0) {
	87	right.setCurrentCE(0);
	88	} else {
	89	break;
	90	}
	91	}
	92	} while(rightPrimary < variableTop &&
	93	rightPrimary > Collation::MERGE_SEPARATOR_PRIMARY);
	94	}
	95	} while(rightPrimary == 0);
	96
	97	if(leftPrimary != rightPrimary) {
	98	// Return the primary difference, with script reordering.
b331163b A	99	if(settings.hasReordering()) {
	100	leftPrimary = settings.reorder(leftPrimary);
	101	rightPrimary = settings.reorder(rightPrimary);
57a6839d A	102	}
	103	return (leftPrimary < rightPrimary) ? UCOL_LESS : UCOL_GREATER;
	104	}
	105	if(leftPrimary == Collation::NO_CE_PRIMARY) { break; }
	106	}
	107	if(U_FAILURE(errorCode)) { return UCOL_EQUAL; }
	108
	109	// Compare the buffered secondary & tertiary weights.
	110	// We might skip the secondary level but continue with the case level
	111	// which is turned on separately.
	112	if(CollationSettings::getStrength(options) >= UCOL_SECONDARY) {
	113	if((options & CollationSettings::BACKWARD_SECONDARY) == 0) {
	114	int32_t leftIndex = 0;
	115	int32_t rightIndex = 0;
	116	for(;;) {
	117	uint32_t leftSecondary;
	118	do {
	119	leftSecondary = ((uint32_t)left.getCE(leftIndex++)) >> 16;
	120	} while(leftSecondary == 0);
	121
	122	uint32_t rightSecondary;
	123	do {
	124	rightSecondary = ((uint32_t)right.getCE(rightIndex++)) >> 16;
	125	} while(rightSecondary == 0);
	126
	127	if(leftSecondary != rightSecondary) {
	128	return (leftSecondary < rightSecondary) ? UCOL_LESS : UCOL_GREATER;
	129	}
	130	if(leftSecondary == Collation::NO_CE_WEIGHT16) { break; }
	131	}
	132	} else {
	133	// The backwards secondary level compares secondary weights backwards
	134	// within segments separated by the merge separator (U+FFFE, weight 02).
	135	int32_t leftStart = 0;
	136	int32_t rightStart = 0;
	137	for(;;) {
	138	// Find the merge separator or the NO_CE terminator.
b331163b	139	uint32_t p;
57a6839d	140	int32_t leftLimit = leftStart;
b331163b A	141	while((p = (uint32_t)(left.getCE(leftLimit) >> 32)) >
	142	Collation::MERGE_SEPARATOR_PRIMARY \|\|
	143	p == 0) {
57a6839d A	144	++leftLimit;
	145	}
	146	int32_t rightLimit = rightStart;
b331163b A	147	while((p = (uint32_t)(right.getCE(rightLimit) >> 32)) >
	148	Collation::MERGE_SEPARATOR_PRIMARY \|\|
	149	p == 0) {
57a6839d A	150	++rightLimit;
	151	}
	152
	153	// Compare the segments.
	154	int32_t leftIndex = leftLimit;
	155	int32_t rightIndex = rightLimit;
	156	for(;;) {
	157	int32_t leftSecondary = 0;
	158	while(leftSecondary == 0 && leftIndex > leftStart) {
	159	leftSecondary = ((uint32_t)left.getCE(--leftIndex)) >> 16;
	160	}
	161
	162	int32_t rightSecondary = 0;
	163	while(rightSecondary == 0 && rightIndex > rightStart) {
	164	rightSecondary = ((uint32_t)right.getCE(--rightIndex)) >> 16;
	165	}
	166
	167	if(leftSecondary != rightSecondary) {
	168	return (leftSecondary < rightSecondary) ? UCOL_LESS : UCOL_GREATER;
	169	}
	170	if(leftSecondary == 0) { break; }
	171	}
	172
	173	// Did we reach the end of either string?
	174	// Both strings have the same number of merge separators,
	175	// or else there would have been a primary-level difference.
	176	U_ASSERT(left.getCE(leftLimit) == right.getCE(rightLimit));
b331163b	177	if(p == Collation::NO_CE_PRIMARY) { break; }
57a6839d A	178	// Skip both merge separators and continue.
	179	leftStart = leftLimit + 1;
	180	rightStart = rightLimit + 1;
	181	}
	182	}
	183	}
	184
	185	if((options & CollationSettings::CASE_LEVEL) != 0) {
	186	int32_t strength = CollationSettings::getStrength(options);
	187	int32_t leftIndex = 0;
	188	int32_t rightIndex = 0;
	189	for(;;) {
	190	uint32_t leftCase, leftLower32, rightCase;
	191	if(strength == UCOL_PRIMARY) {
	192	// Primary+caseLevel: Ignore case level weights of primary ignorables.
	193	// Otherwise we would get a-umlaut > a
	194	// which is not desirable for accent-insensitive sorting.
	195	// Check for (lower 32 bits) == 0 as well because variable CEs are stored
	196	// with only primary weights.
	197	int64_t ce;
	198	do {
	199	ce = left.getCE(leftIndex++);
	200	leftCase = (uint32_t)ce;
	201	} while((uint32_t)(ce >> 32) == 0 \|\| leftCase == 0);
	202	leftLower32 = leftCase;
	203	leftCase &= 0xc000;
	204
	205	do {
	206	ce = right.getCE(rightIndex++);
	207	rightCase = (uint32_t)ce;
	208	} while((uint32_t)(ce >> 32) == 0 \|\| rightCase == 0);
	209	rightCase &= 0xc000;
	210	} else {
	211	// Secondary+caseLevel: By analogy with the above,
	212	// ignore case level weights of secondary ignorables.
	213	//
	214	// Note: A tertiary CE has uppercase case bits (0.0.ut)
	215	// to keep tertiary+caseFirst well-formed.
	216	//
	217	// Tertiary+caseLevel: Also ignore case level weights of secondary ignorables.
	218	// Otherwise a tertiary CE's uppercase would be no greater than
	219	// a primary/secondary CE's uppercase.
	220	// (See UCA well-formedness condition 2.)
	221	// We could construct a special case weight higher than uppercase,
	222	// but it's simpler to always ignore case weights of secondary ignorables,
	223	// turning 0.0.ut into 0.0.0.t.
	224	// (See LDML Collation, Case Parameters.)
	225	do {
	226	leftCase = (uint32_t)left.getCE(leftIndex++);
	227	} while(leftCase <= 0xffff);
	228	leftLower32 = leftCase;
	229	leftCase &= 0xc000;
	230
	231	do {
	232	rightCase = (uint32_t)right.getCE(rightIndex++);
	233	} while(rightCase <= 0xffff);
	234	rightCase &= 0xc000;
	235	}
	236
	237	// No need to handle NO_CE and MERGE_SEPARATOR specially:
	238	// There is one case weight for each previous-level weight,
	239	// so level length differences were handled there.
	240	if(leftCase != rightCase) {
	241	if((options & CollationSettings::UPPER_FIRST) == 0) {
242	return (leftCase < rightCase) ? UCOL_LESS : UCOL_GREATER;
243	} else {
244	return (leftCase < rightCase) ? UCOL_GREATER : UCOL_LESS;
245	}
246	}
247	if((leftLower32 >> 16) == Collation::NO_CE_WEIGHT16) { break; }
248	}
249	}
250	if(CollationSettings::getStrength(options) <= UCOL_SECONDARY) { return UCOL_EQUAL; }
251
252	uint32_t tertiaryMask = CollationSettings::getTertiaryMask(options);
253
254	int32_t leftIndex = 0;
255	int32_t rightIndex = 0;
256	uint32_t anyQuaternaries = 0;
257	for(;;) {
258	uint32_t leftLower32, leftTertiary;
259	do {
260	leftLower32 = (uint32_t)left.getCE(leftIndex++);
261	anyQuaternaries \|= leftLower32;
262	U_ASSERT((leftLower32 & Collation::ONLY_TERTIARY_MASK) != 0 \|\|
263	(leftLower32 & 0xc0c0) == 0);
264	leftTertiary = leftLower32 & tertiaryMask;
265	} while(leftTertiary == 0);
266
267	uint32_t rightLower32, rightTertiary;
268	do {
269	rightLower32 = (uint32_t)right.getCE(rightIndex++);
270	anyQuaternaries \|= rightLower32;
271	U_ASSERT((rightLower32 & Collation::ONLY_TERTIARY_MASK) != 0 \|\|
272	(rightLower32 & 0xc0c0) == 0);
273	rightTertiary = rightLower32 & tertiaryMask;
274	} while(rightTertiary == 0);
275
276	if(leftTertiary != rightTertiary) {
277	if(CollationSettings::sortsTertiaryUpperCaseFirst(options)) {
b331163b	278	// Pass through NO_CE and keep real tertiary weights larger than that.
57a6839d A	279	// Do not change the artificial uppercase weight of a tertiary CE (0.0.ut),
	280	// to keep tertiary CEs well-formed.
	281	// Their case+tertiary weights must be greater than those of
	282	// primary and secondary CEs.
b331163b	283	if(leftTertiary > Collation::NO_CE_WEIGHT16) {
57a6839d A	284	if(leftLower32 > 0xffff) {
	285	leftTertiary ^= 0xc000;
	286	} else {
	287	leftTertiary += 0x4000;
	288	}
	289	}
b331163b	290	if(rightTertiary > Collation::NO_CE_WEIGHT16) {
57a6839d A	291	if(rightLower32 > 0xffff) {
	292	rightTertiary ^= 0xc000;
	293	} else {
	294	rightTertiary += 0x4000;
	295	}
	296	}
	297	}
	298	return (leftTertiary < rightTertiary) ? UCOL_LESS : UCOL_GREATER;
	299	}
	300	if(leftTertiary == Collation::NO_CE_WEIGHT16) { break; }
	301	}
	302	if(CollationSettings::getStrength(options) <= UCOL_TERTIARY) { return UCOL_EQUAL; }
	303
	304	if(!anyVariable && (anyQuaternaries & 0xc0) == 0) {
	305	// If there are no "variable" CEs and no non-zero quaternary weights,
	306	// then there are no quaternary differences.
	307	return UCOL_EQUAL;
	308	}
	309
	310	leftIndex = 0;
	311	rightIndex = 0;
	312	for(;;) {
	313	uint32_t leftQuaternary;
	314	do {
	315	int64_t ce = left.getCE(leftIndex++);
	316	leftQuaternary = (uint32_t)ce & 0xffff;
b331163b A	317	if(leftQuaternary <= Collation::NO_CE_WEIGHT16) {
b331163b A	318	// Variable primary or completely ignorable or NO_CE.
57a6839d	319	leftQuaternary = (uint32_t)(ce >> 32);
57a6839d A	320	} else {
	321	// Regular CE, not tertiary ignorable.
	322	// Preserve the quaternary weight in bits 7..6.
	323	leftQuaternary \|= 0xffffff3f;
	324	}
	325	} while(leftQuaternary == 0);
	326
	327	uint32_t rightQuaternary;
	328	do {
	329	int64_t ce = right.getCE(rightIndex++);
	330	rightQuaternary = (uint32_t)ce & 0xffff;
b331163b A	331	if(rightQuaternary <= Collation::NO_CE_WEIGHT16) {
b331163b A	332	// Variable primary or completely ignorable or NO_CE.
57a6839d	333	rightQuaternary = (uint32_t)(ce >> 32);
57a6839d A	334	} else {
	335	// Regular CE, not tertiary ignorable.
	336	// Preserve the quaternary weight in bits 7..6.
	337	rightQuaternary \|= 0xffffff3f;
	338	}
	339	} while(rightQuaternary == 0);
	340
	341	if(leftQuaternary != rightQuaternary) {
	342	// Return the difference, with script reordering.
b331163b A	343	if(settings.hasReordering()) {
	344	leftQuaternary = settings.reorder(leftQuaternary);
	345	rightQuaternary = settings.reorder(rightQuaternary);
57a6839d A	346	}
	347	return (leftQuaternary < rightQuaternary) ? UCOL_LESS : UCOL_GREATER;
	348	}
b331163b	349	if(leftQuaternary == Collation::NO_CE_PRIMARY) { break; }
57a6839d A	350	}
	351	return UCOL_EQUAL;
	352	}
	353
	354	U_NAMESPACE_END
	355
	356	#endif // !UCONFIG_NO_COLLATION