Lines Matching defs:ce
78 * @param ce 32-bit collation element
82 inline int hashFromCE32(uint32_t ce)
85 ((((((ce >> 24) * 37) +
86 (ce >> 16)) * 37) +
87 (ce >> 8)) * 37) +
88 ce);
157 // if the ce is a variable, we mask and get only the primary values
278 * Initializing the ce table for a pattern.
320 int32_t ce;
322 while ((ce = ucol_next(coleiter, status)) != UCOL_NULLORDER &&
324 uint32_t newce = getCE(strsrch, ce);
339 result += (uint16_t)(ucol_getMaxExpansion(coleiter, ce) - 1);
397 // ** whether a CE is signed or unsigned. For example, look at routine above this one.)
416 //result += (uint16_t)(ucol_getMaxExpansion(coleiter, ce) - 1);
474 * @param cetable table containing pattern ce
539 * If pattern has no non-ignorable ce, we return a illegal argument error.
634 int32_t ce = getCE(strsrch, ucol_next(coleiter, &status));
635 if (ce == UCOL_IGNORABLE) {
639 if (U_FAILURE(status) || ce != strsrch->pattern.ces[count]) {
724 * @param ce the text ce which failed the match.
725 * @param patternceindex index of the ce within the pattern ce buffer which
732 int32_t ce,
736 if (ce != UCOL_NULLORDER) {
737 int32_t shift = pattern->shift[hashFromCE32(ce)];
876 uint32_t ce = UCOL_IGNORABLE;
877 while (U_SUCCESS(*status) && ce != firstce && ce != (uint32_t)UCOL_NULLORDER) {
879 if (ce != firstce && ce
882 ce = ucol_next(coleiter, status);
902 * the first pattern ce does not match the first ce of the character, we bail.
908 * first or last ce that match has to occur within the first character.
930 int32_t ce = getCE(strsrch, ucol_next(coleiter, &status));
934 while (ce != firstce) {
935 if (ce != UCOL_IGNORABLE) {
938 ce = getCE(strsrch, ucol_next(coleiter, &status));
939 if (U_FAILURE(status) || ce == UCOL_NULLORDER) {
971 ce = ucol_previous(coleiter, &status);
973 (ce != UCOL_NULLORDER && ce != UCOL_IGNORABLE)) {
1012 int32_t ce;
1014 while ((ce = getCE(strsrch, ucol_next(coleiter, &status))) != firstce) {
1015 if (U_FAILURE(status) || ce == UCOL_NULLORDER) {
1032 ce = ucol_next(coleiter, &status);
1036 if (ce != UCOL_NULLORDER && ce != UCOL_IGNORABLE) {
1037 ce = getCE(strsrch, ce);
1039 if (ce != UCOL_NULLORDER && ce != UCOL_IGNORABLE) {
1186 // getting rid of the redundant ce, caused by setOffset.
1192 // have to skip the first ce in the expansion buffer.
1208 int32_t ce = getCE(strsrch, ucol_next(coleiter, status));
1209 if (ce == UCOL_IGNORABLE) {
1216 if (U_FAILURE(*status) || ce != patternce[count]) {
1411 int32_t ce = getCE(strsrch, ucol_next(coleiter, &status));
1412 if (ce == UCOL_IGNORABLE) {
1415 if (U_FAILURE(status) || ce != *patternce) {
1607 int32_t *ce = strsrch->pattern.ces;
1635 if (textce != UCOL_IGNORABLE && textce != ce[ceindex]) {
1662 if (textce == ce[ceindex]) {
1690 * equivalents and check their corresponding ces with the pattern ce.
1829 // getting rid of the redundant ce, caused by setOffset.
1835 // have to skip the first ce in the expansion buffer.
1852 int32_t ce = getCE(strsrch, ucol_next(coleiter, status));
1855 if (ce == UCOL_IGNORABLE) {
1863 if (count == 0 && ce != patternce[0]) {
1869 ce = getCE(strsrch, ucol_next(coleiter, status));
1870 while (U_SUCCESS(*status) && ce != expected &&
1871 ce != UCOL_NULLORDER &&
1873 ce = getCE(strsrch, ucol_next(coleiter, status));
1877 if (U_FAILURE(*status) || ce != patternce[count]) {
1957 * @param ce the text ce which failed the match.
1958 * @param patternceindex index of the ce within the pattern ce buffer which
1965 int32_t ce,
1977 if (ce != UCOL_NULLORDER) {
1978 int32_t shift = strsrch->pattern.backShift[hashFromCE32(ce)];
2027 // getting rid of the redundant ce
2033 // last ce in the expansion buffer
2049 int32_t ce = getCE(strsrch, ucol_previous(coleiter, status));
2052 if (ce == UCOL_IGNORABLE) {
2060 if (U_FAILURE(*status) || ce != patternce[count - 1]) {
2270 int32_t *ce = strsrch->pattern.ces;
2299 if (textce != UCOL_IGNORABLE && textce != ce[ceindex]) {
2326 if (textce == ce[ceindex]) {
2353 * canonical equivalents and check their corresponding ces with the pattern ce.
2467 // getting rid of the redundant ce
2473 // last ce in the expansion buffer
2489 int32_t ce = getCE(strsrch, ucol_previous(coleiter, status));
2492 if (ce == UCOL_IGNORABLE) {
2501 ce != patternce[patterncelength - 1]) {
2507 ce = getCE(strsrch, ucol_previous(coleiter, status));
2508 while (U_SUCCESS(*status) && ce != expected &&
2509 ce != UCOL_NULLORDER &&
2511 ce = getCE(strsrch, ucol_previous(coleiter, status));
2515 if (U_FAILURE(*status) || ce != patternce[count - 1]) {
3447 int64_t ce;
3526 // Get the CE with the specified index.
3530 // The CE value will be UCOL__PROCESSED_NULLORDER at end of input.
3541 // Caller is requesting a new, never accessed before, CE.
3550 // Manage the circular CE buffer indexing
3560 buf[i].ce = strSearch->textProcessedIter->nextProcessed(&buf[i].lowIndex, &buf[i].highIndex, &status);
3565 // Get the CE with the specified index.
3569 // The CE value will be UCOL__PROCESSED_NULLORDER at end of input.
3580 // Caller is requesting a new, never accessed before, CE.
3589 // Manage the circular CE buffer indexing
3599 buf[i].ce = strSearch->textProcessedIter->previousProcessed(&buf[i].lowIndex, &buf[i].highIndex, &status);
3888 // target CE space.
3892 // 2. An int64_t CE weight is determined for each resulting unit (high 16 bits are primary strength, next
3895 // CE weight 0 (as for a combining diacritic with secondary weight when the collator strentgh is primary),
3896 // then the CE is deleted, so the following code sees only CEs that are relevant.
3897 // For each CE, the lowIndex and highIndex correspond to where this CE begins and ends in the original text.
3898 // If lowIndex==highIndex, either the CE resulted from an expansion/decomposition of one of the original text
3899 // characters, or the CE marks the limit of the target text (in which case the CE weight is UCOL_PROCESSED_NULLORDER).
3908 // For targetIx > 0, this ceb.get gets a CE that is as far back in the ring buffer
3909 // (compared to the last CE fetched for the previous targetIx value) as we need to go
3921 // Compare CE from target string with CE from the pattern.
3922 // Note that the target CE will be UCOL_PROCESSED_NULLORDER if we reach the end of input,
3924 UCompareCEsResult ceMatch = compareCE64s(targetCEI->ce, patCE, strsrch->search->elementComparisonType);
3939 targetIxOffset += strsrch->pattern.pcesLength; // this is now the offset in target CE space to end of the match so far
3941 if (!found && ((targetCEI == NULL) || (targetCEI->ce != UCOL_PROCESSED_NULLORDER))) {
3952 // We have found a match in CE space.
3954 // There still is a chance of match failure if the CE range not correspond to
3962 // Look at the CE following the match. If it is UCOL_NULLORDER the match
3965 // Look at the high and low indices of the CE following the match. If
3967 // 1. The match extended to the last CE from the target text, which is OK, or
3968 // 2. The last CE that was part of the match is in an expansion that extends
3969 // to the first CE after the match. In this case, we reject the match.
3974 if (nextCEI->lowIndex == nextCEI->highIndex && nextCEI->ce != UCOL_PROCESSED_NULLORDER) {
3982 if ( nextCEI->ce == UCOL_PROCESSED_NULLORDER ) {
3985 // As long as the next CE has primary weight of 0,
3988 if ( (((nextCEI->ce) >> 32) & 0xFFFF0000UL) == 0 ) {
3989 UCompareCEsResult ceMatch = compareCE64s(nextCEI->ce, patCE, strsrch->search->elementComparisonType);
3994 // If lowIndex == highIndex, this target CE is part of an expansion of the last matched
3999 // Else the target CE is not part of an expansion of the last matched element, match succeeds
4019 // With exapnsions, the first CE will report the index of the source
4042 nextCEI != NULL && (((nextCEI->ce) >> 32) & 0xFFFF0000UL) != 0 &&
4052 // * do NOT require that end of the combining sequence not extend beyond the match in CE space
4059 // When the last CE's low index is same with its high index, the CE is likely
4064 // the position and the next character produces CE(s). See ticket#8482.
4086 // advanced us beyond the end of the match in CE space, reject this match.
4110 printf("%8x@%d ", ceb.get(ii)->ce, ceb.get(ii)->srcIndex);
4175 * Pre-load the buffer with the CE's for the grapheme
4177 * we can look at the CE following the match when we
4180 * This will also pre-fetch the first CE that we'll
4212 // target CE space.
4220 // For targetIx > limitIx, this ceb.getPrevious gets a CE that is as far back in the ring buffer
4221 // (compared to the last CE fetched for the previous targetIx value) as we need to go
4236 // Compare CE from target string with CE from the pattern.
4237 // Note that the target CE will be UCOL_NULLORDER if we reach the end of input,
4239 UCompareCEsResult ceMatch = compareCE64s(targetCEI->ce, patCE, strsrch->search->elementComparisonType);
4255 if (!found && ((targetCEI == NULL) || (targetCEI->ce != UCOL_PROCESSED_NULLORDER))) {
4266 // We have found a match in CE space.
4268 // There still is a chance of match failure if the CE range not correspond to
4284 // Look at the high index of the first CE in the match. If it's the same as the
4285 // low index, the first CE in the match is in the middle of an expansion.
4294 // Look at the CE
4297 // Look at the high and low indices of the CE following the match. If
4299 // 1. The match extended to the last CE from the target text, which is OK, or
4300 // 2. The last CE that was part of the match is in an expansion that extends
4301 // to the first CE after the match. In this case, we reject the match.
4304 if (nextCEI->lowIndex == nextCEI->highIndex && nextCEI->ce != UCOL_PROCESSED_NULLORDER) {
4325 nextCEI != NULL && (((nextCEI->ce) >> 32) & 0xFFFF0000UL) != 0 &&
4335 // * do NOT require that end of the combining sequence not extend beyond the match in CE space
4352 // advanced us beyond the end of the match in CE space, reject this match.
4366 // the last non-ignorable CE. Combining sequence
4393 printf("%8x@%d ", ceb.get(ii)->ce, ceb.get(ii)->srcIndex);
4448 // finding the last pattern ce match, imagine composite characters
4467 // the first ce can be a contraction
4564 // finding the last pattern ce match, imagine composite characters
4578 // the first ce can be a contraction
4682 // finding the first pattern ce match, imagine composite
4830 // finding the first pattern ce match, imagine composite
4846 // the first ce can be a contraction
