Lines Matching refs:ut
37 utext_access(UText *ut, int64_t index, UBool forward) {
38 return ut->pFuncs->access(ut, index, forward);
44 utext_moveIndex32(UText *ut, int32_t delta) {
48 if(ut->chunkOffset>=ut->chunkLength && !utext_access(ut, ut->chunkNativeLimit, TRUE)) {
51 c = ut->chunkContents[ut->chunkOffset];
53 c = utext_next32(ut);
58 ut->chunkOffset++;
64 if(ut->chunkOffset<=0 && !utext_access(ut, ut->chunkNativeStart, FALSE)) {
67 c = ut->chunkContents[ut->chunkOffset-1];
69 c = utext_previous32(ut);
74 ut->chunkOffset--;
84 utext_nativeLength(UText *ut) {
85 return ut->pFuncs->nativeLength(ut);
90 utext_isLengthExpensive(const UText *ut) {
91 UBool r = (ut->providerProperties & I32_FLAG(UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE)) != 0;
97 utext_getNativeIndex(const UText *ut) {
98 if(ut->chunkOffset <= ut->nativeIndexingLimit) {
99 return ut->chunkNativeStart+ut->chunkOffset;
101 return ut->pFuncs->mapOffsetToNative(ut);
107 utext_setNativeIndex(UText *ut, int64_t index) {
108 if(index<ut->chunkNativeStart || index>=ut->chunkNativeLimit) {
113 ut->pFuncs->access(ut, index, TRUE);
114 } else if((int32_t)(index - ut->chunkNativeStart) <= ut->nativeIndexingLimit) {
116 ut->chunkOffset=(int32_t)(index-ut->chunkNativeStart);
118 ut->chunkOffset=ut->pFuncs->mapNativeIndexToUTF16(ut, index);
122 if (ut->chunkOffset<ut->chunkLength) {
123 UChar c= ut->chunkContents[ut->chunkOffset];
125 if (ut->chunkOffset==0) {
126 ut->pFuncs->access(ut, ut->chunkNativeStart, FALSE);
128 if (ut->chunkOffset>0) {
129 UChar lead = ut->chunkContents[ut->chunkOffset-1];
131 ut->chunkOffset--;
141 utext_getPreviousNativeIndex(UText *ut) {
147 int32_t i = ut->chunkOffset - 1;
150 UChar c = ut->chunkContents[i];
152 if (i <= ut->nativeIndexingLimit) {
153 result = ut->chunkNativeStart + i;
155 ut->chunkOffset = i;
156 result = ut->pFuncs->mapOffsetToNative(ut);
157 ut->chunkOffset++;
164 if (ut->chunkOffset==0 && ut->chunkNativeStart==0) {
171 utext_previous32(ut);
172 result = UTEXT_GETNATIVEINDEX(ut);
173 utext_next32(ut);
184 utext_current32(UText *ut) {
186 if (ut->chunkOffset==ut->chunkLength) {
188 if (ut->pFuncs->access(ut, ut->chunkNativeLimit, TRUE) == FALSE) {
194 c = ut->chunkContents[ut->chunkOffset];
205 if ((ut->chunkOffset+1) < ut->chunkLength) {
207 trail = ut->chunkContents[ut->chunkOffset+1];
216 int64_t nativePosition = ut->chunkNativeLimit;
217 int32_t originalOffset = ut->chunkOffset;
218 if (ut->pFuncs->access(ut, nativePosition, TRUE)) {
219 trail = ut->chunkContents[ut->chunkOffset];
221 UBool r = ut->pFuncs->access(ut, nativePosition, FALSE); // reverse iteration flag loads preceding chunk
223 ut->chunkOffset = originalOffset;
238 utext_char32At(UText *ut, int64_t nativeIndex) {
242 if (nativeIndex>=ut->chunkNativeStart && nativeIndex < ut->chunkNativeStart + ut->nativeIndexingLimit) {
243 ut->chunkOffset = (int32_t)(nativeIndex - ut->chunkNativeStart);
244 c = ut->chunkContents[ut->chunkOffset];
251 utext_setNativeIndex(ut, nativeIndex);
252 if (nativeIndex>=ut->chunkNativeStart && ut->chunkOffset<ut->chunkLength) {
253 c = ut->chunkContents[ut->chunkOffset];
257 c = utext_current32(ut);
265 utext_next32(UText *ut) {
268 if (ut->chunkOffset >= ut->chunkLength) {
269 if (ut->pFuncs->access(ut, ut->chunkNativeLimit, TRUE) == FALSE) {
274 c = ut->chunkContents[ut->chunkOffset++];
282 if (ut->chunkOffset >= ut->chunkLength) {
283 if (ut->pFuncs->access(ut, ut->chunkNativeLimit, TRUE) == FALSE) {
289 UChar32 trail = ut->chunkContents[ut->chunkOffset];
299 ut->chunkOffset++; // move iteration position over the trail surrogate.
305 utext_previous32(UText *ut) {
308 if (ut->chunkOffset <= 0) {
309 if (ut->pFuncs->access(ut, ut->chunkNativeStart, FALSE) == FALSE) {
313 ut->chunkOffset--;
314 c = ut->chunkContents[ut->chunkOffset];
322 if (ut->chunkOffset <= 0) {
323 if (ut->pFuncs->access(ut, ut->chunkNativeStart, FALSE) == FALSE) {
330 UChar32 lead = ut->chunkContents[ut->chunkOffset-1];
338 ut->chunkOffset--; // move iteration position over the lead surrogate.
345 utext_next32From(UText *ut, int64_t index) {
348 if(index<ut->chunkNativeStart || index>=ut->chunkNativeLimit) {
350 if(!ut->pFuncs->access(ut, index, TRUE)) {
354 } else if (index - ut->chunkNativeStart <= (int64_t)ut->nativeIndexingLimit) {
356 ut->chunkOffset = (int32_t)(index - ut->chunkNativeStart);
359 ut->chunkOffset = ut->pFuncs->mapNativeIndexToUTF16(ut, index);
362 c = ut->chunkContents[ut->chunkOffset++];
366 utext_setNativeIndex(ut, index);
367 c = utext_next32(ut);
374 utext_previous32From(UText *ut, int64_t index) {
388 if(index<=ut->chunkNativeStart || index>ut->chunkNativeLimit) {
390 if(!ut->pFuncs->access(ut, index, FALSE)) {
394 } else if(index - ut->chunkNativeStart <= (int64_t)ut->nativeIndexingLimit) {
396 ut->chunkOffset = (int32_t)(index - ut->chunkNativeStart);
398 ut->chunkOffset=ut->pFuncs->mapNativeIndexToUTF16(ut, index);
399 if (ut->chunkOffset==0 && !ut->pFuncs->access(ut, index, FALSE)) {
408 ut->chunkOffset--;
409 cPrev = ut->chunkContents[ut->chunkOffset];
414 utext_setNativeIndex(ut, index);
415 cPrev = utext_previous32(ut);
422 utext_extract(UText *ut,
426 return ut->pFuncs->extract(ut, start, limit, dest, destCapacity, status);
458 utext_isWritable(const UText *ut)
460 UBool b = (ut->providerProperties & I32_FLAG(UTEXT_PROVIDER_WRITABLE)) != 0;
466 utext_freeze(UText *ut) {
468 ut->providerProperties &= ~(I32_FLAG(UTEXT_PROVIDER_WRITABLE));
473 utext_hasMetaData(const UText *ut)
475 UBool b = (ut->providerProperties & I32_FLAG(UTEXT_PROVIDER_HAS_META_DATA)) != 0;
482 utext_replace(UText *ut,
490 if ((ut->providerProperties & I32_FLAG(UTEXT_PROVIDER_WRITABLE)) == 0) {
494 int32_t i = ut->pFuncs->replace(ut, nativeStart, nativeLimit, replacementText, replacementLength, status);
499 utext_copy(UText *ut,
508 if ((ut->providerProperties & I32_FLAG(UTEXT_PROVIDER_WRITABLE)) == 0) {
512 ut->pFuncs->copy(ut, nativeStart, nativeLimit, destIndex, move, status);
558 UText ut;
565 utext_setup(UText *ut, int32_t extraSpace, UErrorCode *status) {
567 return ut;
570 if (ut == NULL) {
576 ut = (UText *)uprv_malloc(spaceRequired);
577 if (ut == NULL) {
581 *ut = emptyText;
582 ut->flags |= UTEXT_HEAP_ALLOCATED;
584 ut->extraSize = extraSpace;
585 ut->pExtra = &((ExtendedUText *)ut)->extension;
591 if (ut->magic != UTEXT_MAGIC) {
593 return ut;
595 // If the ut is already open and there's a provider supplied close
597 if ((ut->flags & UTEXT_OPEN) && ut->pFuncs->close != NULL) {
598 ut->pFuncs->close(ut);
600 ut->flags &= ~UTEXT_OPEN;
604 if (extraSpace > ut->extraSize) {
607 if (ut->flags & UTEXT_EXTRA_HEAP_ALLOCATED) {
608 uprv_free(ut->pExtra);
609 ut->extraSize = 0;
611 ut->pExtra = uprv_malloc(extraSpace);
612 if (ut->pExtra == NULL) {
615 ut->extraSize = extraSpace;
616 ut->flags |= UTEXT_EXTRA_HEAP_ALLOCATED;
621 ut->flags |= UTEXT_OPEN;
625 ut->context = NULL;
626 ut->chunkContents = NULL;
627 ut->p = NULL;
628 ut->q = NULL;
629 ut->r = NULL;
630 ut->a = 0;
631 ut->b = 0;
632 ut->c = 0;
633 ut->chunkOffset = 0;
634 ut->chunkLength = 0;
635 ut->chunkNativeStart = 0;
636 ut->chunkNativeLimit = 0;
637 ut->nativeIndexingLimit = 0;
638 ut->providerProperties = 0;
639 ut->privA = 0;
640 ut->privB = 0;
641 ut->privC = 0;
642 ut->privP = NULL;
643 if (ut->pExtra!=NULL && ut->extraSize>0)
644 uprv_memset(ut->pExtra, 0, ut->extraSize);
647 return ut;
652 utext_close(UText *ut) {
653 if (ut==NULL ||
654 ut->magic != UTEXT_MAGIC ||
655 (ut->flags & UTEXT_OPEN) == 0)
657 // The supplied ut is not an open UText.
659 return ut;
664 if (ut->pFuncs->close != NULL) {
665 ut->pFuncs->close(ut);
667 ut->flags &= ~UTEXT_OPEN;
671 if (ut->flags & UTEXT_EXTRA_HEAP_ALLOCATED) {
672 uprv_free(ut->pExtra);
673 ut->pExtra = NULL;
674 ut->flags &= ~UTEXT_EXTRA_HEAP_ALLOCATED;
675 ut->extraSize = 0;
681 ut->pFuncs = NULL;
683 if (ut->flags & UTEXT_HEAP_ALLOCATED) {
687 ut->magic = 0;
688 uprv_free(ut);
689 ut = NULL;
691 return ut;
705 invalidateChunk(UText *ut) {
706 ut->chunkLength = 0;
707 ut->chunkNativeLimit = 0;
708 ut->chunkNativeStart = 0;
709 ut->chunkOffset = 0;
710 ut->nativeIndexingLimit = 0;
890 utf8TextLength(UText *ut) {
891 if (ut->b < 0) {
894 const char *r = (const char *)ut->context + ut->c;
898 if ((r - (const char *)ut->context) < 0x7fffffff) {
899 ut->b = (int32_t)(r - (const char *)ut->context);
903 ut->b = 0x7fffffff;
905 ut->providerProperties &= ~I32_FLAG(UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE);
907 return ut->b;
916 utf8TextAccess(UText *ut, int64_t index, UBool forward) {
923 const uint8_t *s8=(const uint8_t *)ut->context;
925 int32_t length = ut->b; // Length of original utf-8
939 } else if (ix>=ut->c) {
944 while (ut->c<ix && s8[ut->c]!=0) {
945 ut->c++;
948 if (s8[ut->c] == 0) {
951 ix = ut->c;
952 ut->b = ut->c;
953 length = ut->c;
954 ut->providerProperties &= ~I32_FLAG(UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE);
963 if (ix==ut->chunkNativeLimit) {
969 ut->chunkOffset = ut->chunkLength;
974 UTF8Buf *altB = (UTF8Buf *)ut->q;
986 u8b = (UTF8Buf *)ut->q; // the alternate buffer
995 if (ix == ut->chunkNativeLimit) {
998 ut->chunkOffset = ut->chunkLength;
1011 if (ix<ut->chunkNativeStart || ix>=ut->chunkNativeLimit) {
1017 u8b = (UTF8Buf *)ut->p; // the current buffer
1019 ut->chunkOffset = u8b->mapToUChars[mapIndex] - u8b->bufStartIdx;
1030 if (ix==ut->chunkNativeStart) {
1036 ut->chunkOffset = 0;
1041 UTF8Buf *altB = (UTF8Buf *)ut->q;
1053 u8b = (UTF8Buf *)ut->q; // the alternate buffer
1074 if (ix<=ut->chunkNativeStart || ix>ut->chunkNativeLimit) {
1081 u8b = (UTF8Buf *)ut->p;
1083 ut->chunkOffset = u8b->mapToUChars[mapIndex] - u8b->bufStartIdx;
1084 if (ut->chunkOffset==0) {
1098 // The alternate buffer (ut->q) has the string data that was requested.
1102 u8b = (UTF8Buf *)ut->q;
1103 ut->q = ut->p;
1104 ut->p = u8b;
1105 ut->chunkContents = &u8b->buf[u8b->bufStartIdx];
1106 ut->chunkLength = u8b->bufLimitIdx - u8b->bufStartIdx;
1107 ut->chunkNativeStart = u8b->bufNativeStart;
1108 ut->chunkNativeLimit = u8b->bufNativeLimit;
1109 ut->nativeIndexingLimit = u8b->bufNILimit;
1119 ut->chunkOffset = u8b->mapToUChars[mapIndex] - u8b->bufStartIdx;
1134 u8b = (UTF8Buf *)ut->q;
1135 ut->q = ut->p;
1136 ut->p = u8b;
1137 ut->chunkContents = &u8b->buf[u8b->bufStartIdx];
1138 ut->chunkLength = u8b->bufLimitIdx - u8b->bufStartIdx;
1139 ut->chunkNativeStart = u8b->bufNativeStart;
1140 ut->chunkNativeLimit = u8b->bufNativeLimit;
1141 ut->nativeIndexingLimit = u8b->bufNILimit;
1147 ut->chunkOffset = ut->chunkLength;
1149 ut->chunkOffset = 0;
1159 u8b = (UTF8Buf *)ut->q;
1180 UTF8Buf *u8b = (UTF8Buf *)ut->q;
1181 ut->q = ut->p;
1182 ut->p = u8b;
1184 int32_t strLen = ut->b;
1257 ut->chunkContents = buf;
1258 ut->chunkOffset = 0;
1259 ut->chunkLength = u8b->bufLimitIdx;
1260 ut->chunkNativeStart = u8b->bufNativeStart;
1261 ut->chunkNativeLimit = u8b->bufNativeLimit;
1262 ut->nativeIndexingLimit = u8b->bufNILimit;
1266 if (nulTerminated && srcIx>ut->c) {
1267 ut->c = srcIx;
1271 ut->b = srcIx;
1272 ut->providerProperties &= ~I32_FLAG(UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE);
1284 if (ix != ut->b) {
1291 UTF8Buf *u8b = (UTF8Buf *)ut->q;
1292 ut->q = ut->p;
1293 ut->p = u8b;
1369 ut->chunkContents = &buf[u8b->bufStartIdx];
1370 ut->chunkLength = u8b->bufLimitIdx - u8b->bufStartIdx;
1371 ut->chunkOffset = ut->chunkLength;
1372 ut->chunkNativeStart = u8b->bufNativeStart;
1373 ut->chunkNativeLimit = u8b->bufNativeLimit;
1374 ut->nativeIndexingLimit = u8b->bufNILimit;
1450 utf8TextExtract(UText *ut,
1461 int32_t length = ut->b;
1474 const uint8_t *buf = (const uint8_t *)ut->context;
1476 if (start32 < ut->chunkNativeLimit) {
1485 if (limit32 < ut->chunkNativeLimit) {
1497 (const char *)ut->context+start32, limit32-start32,
1499 utf8TextAccess(ut, limit32, TRUE);
1508 utf8TextMapOffsetToNative(const UText *ut) {
1510 UTF8Buf *u8b = (UTF8Buf *)ut->p;
1511 U_ASSERT(ut->chunkOffset>ut->nativeIndexingLimit && ut->chunkOffset<=ut->chunkLength);
1512 int32_t nativeOffset = u8b->mapToNative[ut->chunkOffset + u8b->bufStartIdx] + u8b->toUCharsMapStart;
1513 U_ASSERT(nativeOffset >= ut->chunkNativeStart && nativeOffset <= ut->chunkNativeLimit);
1521 utf8TextMapIndexToUTF16(const UText *ut, int64_t index64) {
1524 UTF8Buf *u8b = (UTF8Buf *)ut->p;
1525 U_ASSERT(index>=ut->chunkNativeStart+ut->nativeIndexingLimit);
1526 U_ASSERT(index<=ut->chunkNativeLimit);
1529 U_ASSERT(offset>=0 && offset<=ut->chunkLength);
1564 utf8TextClose(UText *ut) {
1568 if (ut->providerProperties & I32_FLAG(UTEXT_PROVIDER_OWNS_TEXT)) {
1569 char *s = (char *)ut->context;
1571 ut->context = NULL;
1600 utext_openUTF8(UText *ut, const char *s, int64_t length, UErrorCode *status) {
1613 ut = utext_setup(ut, sizeof(UTF8Buf) * 2, status);
1615 return ut;
1618 ut->pFuncs = &utf8Funcs;
1619 ut->context = s;
1620 ut->b = (int32_t)length;
1621 ut->c = (int32_t)length;
1622 if (ut->c < 0) {
1623 ut->c = 0;
1624 ut->providerProperties |= I32_FLAG(UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE);
1626 ut->p = ut->pExtra;
1627 ut->q = (char *)ut->pExtra + sizeof(UTF8Buf);
1628 return ut;
1689 repTextClose(UText *ut) {
1693 if (ut->providerProperties & I32_FLAG(UTEXT_PROVIDER_OWNS_TEXT)) {
1694 Replaceable *rep = (Replaceable *)ut->context;
1696 ut->context = NULL;
1702 repTextLength(UText *ut) {
1703 const Replaceable *replSrc = (const Replaceable *)ut->context;
1710 repTextAccess(UText *ut, int64_t index, UBool forward) {
1711 const Replaceable *rep=(const Replaceable *)ut->context;
1729 if (index32>=ut->chunkNativeStart && index32<ut->chunkNativeLimit) {
1731 ut->chunkOffset = (int32_t)(index - ut->chunkNativeStart);
1734 if (index32>=length && ut->chunkNativeLimit==length) {
1737 ut->chunkOffset = length - (int32_t)ut->chunkNativeStart;
1741 ut->chunkNativeLimit = index + REP_TEXT_CHUNK_SIZE - 1;
1746 if(ut->chunkNativeLimit > length) {
1747 ut->chunkNativeLimit = length;
1750 ut->chunkNativeStart = ut->chunkNativeLimit - REP_TEXT_CHUNK_SIZE;
1751 if(ut->chunkNativeStart < 0) {
1752 ut->chunkNativeStart = 0;
1756 if (index32>ut->chunkNativeStart && index32<=ut->chunkNativeLimit) {
1758 ut->chunkOffset = index32 - (int32_t)ut->chunkNativeStart;
1761 if (index32==0 && ut->chunkNativeStart==0) {
1764 ut->chunkOffset = 0;
1774 ut->chunkNativeStart = index32 + 1 - REP_TEXT_CHUNK_SIZE;
1775 if (ut->chunkNativeStart < 0) {
1776 ut->chunkNativeStart = 0;
1779 ut->chunkNativeLimit = index32 + 1;
1780 if (ut->chunkNativeLimit > length) {
1781 ut->chunkNativeLimit = length;
1786 ReplExtra *ex = (ReplExtra *)ut->pExtra;
1789 rep->extractBetween((int32_t)ut->chunkNativeStart, (int32_t)ut->chunkNativeLimit, buffer);
1791 ut->chunkContents = ex->s;
1792 ut->chunkLength = (int32_t)(ut->chunkNativeLimit - ut->chunkNativeStart);
1793 ut->chunkOffset = (int32_t)(index32 - ut->chunkNativeStart);
1797 if (ut->chunkNativeLimit < length &&
1798 U16_IS_LEAD(ex->s[ut->chunkLength-1])) {
1799 ut->chunkLength--;
1800 ut->chunkNativeLimit--;
1801 if (ut->chunkOffset > ut->chunkLength) {
1802 ut->chunkOffset = ut->chunkLength;
1808 if(ut->chunkNativeStart>0 && U16_IS_TRAIL(ex->s[0])) {
1809 ++(ut->chunkContents);
1810 ++(ut->chunkNativeStart);
1811 --(ut->chunkLength);
1812 --(ut->chunkOffset);
1816 U16_SET_CP_START(ut->chunkContents, 0, ut->chunkOffset);
1819 ut->nativeIndexingLimit = ut->chunkLength;
1827 repTextExtract(UText *ut,
1831 const Replaceable *rep=(const Replaceable *)ut->context;
1864 repTextAccess(ut, limit32, TRUE);
1870 repTextReplace(UText *ut,
1874 Replaceable *rep=(Replaceable *)ut->context;
1912 if (ut->chunkNativeLimit > start32) {
1915 invalidateChunk(ut);
1920 repTextAccess(ut, newIndexPos, TRUE);
1927 repTextCopy(UText *ut,
1933 Replaceable *rep=(Replaceable *)ut->context;
1971 if (firstAffectedIndex < ut->chunkNativeLimit) {
1973 invalidateChunk(ut);
1984 repTextAccess(ut, nativeIterIndex, TRUE);
2007 utext_openReplaceable(UText *ut, Replaceable *rep, UErrorCode *status)
2016 ut = utext_setup(ut, sizeof(ReplExtra), status);
2018 ut->providerProperties = I32_FLAG(UTEXT_PROVIDER_WRITABLE);
2020 ut->providerProperties |=I32_FLAG(UTEXT_PROVIDER_HAS_META_DATA);
2023 ut->pFuncs = &repFuncs;
2024 ut->context = rep;
2025 return ut;
2075 unistrTextClose(UText *ut) {
2079 if (ut->providerProperties & I32_FLAG(UTEXT_PROVIDER_OWNS_TEXT)) {
2080 UnicodeString *str = (UnicodeString *)ut->context;
2082 ut->context = NULL;
2094 unistrTextAccess(UText *ut, int64_t index, UBool forward) {
2095 int32_t length = ut->chunkLength;
2096 ut->chunkOffset = pinIndex(index, length);
2143 unistrTextReplace(UText *ut,
2147 UnicodeString *us=(UnicodeString *)ut->context;
2175 ut->chunkContents = us->getBuffer();
2176 ut->chunkLength = newLength;
2177 ut->chunkNativeLimit = newLength;
2178 ut->nativeIndexingLimit = newLength;
2182 ut->chunkOffset = limit32 + lengthDelta;
2188 unistrTextCopy(UText *ut,
2193 UnicodeString *us=(UnicodeString *)ut->context;
2222 ut->chunkContents = us->getBuffer();
2225 ut->chunkLength += limit32-start32;
2226 ut->chunkNativeLimit = ut->chunkLength;
2227 ut->nativeIndexingLimit = ut->chunkLength;
2231 ut->chunkOffset = destIndex32+limit32-start32;
2233 ut->chunkOffset = destIndex32;
2262 utext_openUnicodeString(UText *ut, UnicodeString *s, UErrorCode *status) {
2263 ut = utext_openConstUnicodeString(ut, s, status);
2265 ut->providerProperties |= I32_FLAG(UTEXT_PROVIDER_WRITABLE);
2267 return ut;
2273 utext_openConstUnicodeString(UText *ut, const UnicodeString *s, UErrorCode *status) {
2277 utext_openUChars(ut, NULL, 0, status);
2279 return ut;
2281 ut = utext_setup(ut, 0, status);
2286 ut->pFuncs = &unistrFuncs;
2287 ut->context = s;
2288 ut->providerProperties = I32_FLAG(UTEXT_PROVIDER_STABLE_CHUNKS);
2289 ut->chunkContents = s->getBuffer();
2290 ut->chunkLength = s->length();
2291 ut->chunkNativeStart = 0;
2292 ut->chunkNativeLimit = ut->chunkLength;
2293 ut->nativeIndexingLimit = ut->chunkLength;
2295 return ut;
2347 ucstrTextClose(UText *ut) {
2351 if (ut->providerProperties & I32_FLAG(UTEXT_PROVIDER_OWNS_TEXT)) {
2352 UChar *s = (UChar *)ut->context;
2354 ut->context = NULL;
2361 ucstrTextLength(UText *ut) {
2362 if (ut->a < 0) {
2366 const UChar *str = (const UChar *)ut->context;
2368 if (str[ut->chunkNativeLimit] == 0) {
2371 ut->chunkNativeLimit++;
2373 ut->a = ut->chunkNativeLimit;
2374 ut->chunkLength = (int32_t)ut->chunkNativeLimit;
2375 ut->nativeIndexingLimit = ut->chunkLength;
2376 ut->providerProperties &= ~I32_FLAG(UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE);
2378 return ut->a;
2383 ucstrTextAccess(UText *ut, int64_t index, UBool forward) {
2384 const UChar *str = (const UChar *)ut->context;
2390 } else if (index < ut->chunkNativeLimit) {
2394 } else if (ut->a >= 0) {
2397 index = ut->a;
2409 int32_t chunkLimit = (int32_t)ut->chunkNativeLimit;
2414 ut->a = chunkLimit;
2415 ut->chunkLength = chunkLimit;
2416 ut->nativeIndexingLimit = chunkLimit;
2423 ut->chunkNativeLimit = chunkLimit;
2424 ut->providerProperties &= ~I32_FLAG(UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE);
2434 ut->a = chunkLimit;
2435 ut->chunkLength = chunkLimit;
2436 ut->nativeIndexingLimit = chunkLimit;
2440 ut->chunkNativeLimit = chunkLimit;
2441 ut->providerProperties &= ~I32_FLAG(UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE);
2453 // ut->a being < 0.
2454 ut->chunkNativeLimit = chunkLimit;
2455 ut->nativeIndexingLimit = chunkLimit;
2456 ut->chunkLength = chunkLimit;
2462 ut->chunkOffset = (int32_t)index;
2465 UBool retVal = (forward && index<ut->chunkNativeLimit) || (!forward && index>0);
2472 ucstrTextExtract(UText *ut,
2485 //const UChar *s=(const UChar *)ut->context;
2494 ucstrTextAccess(ut, start, TRUE);
2495 const UChar *s=ut->chunkContents;
2496 start32 = ut->chunkOffset;
2498 int32_t strLength=(int32_t)ut->a;
2508 ut->a = si; // set string length for this UText
2509 ut->chunkNativeLimit = si;
2510 ut->chunkLength = si;
2511 ut->nativeIndexingLimit = si;
2543 ut->chunkOffset = uprv_min(strLength, start32 + destCapacity);
2574 utext_openUChars(UText *ut, const UChar *s, int64_t length, UErrorCode *status) {
2585 ut = utext_setup(ut, 0, status);
2587 ut->pFuncs = &ucstrFuncs;
2588 ut->context = s;
2589 ut->providerProperties = I32_FLAG(UTEXT_PROVIDER_STABLE_CHUNKS);
2591 ut->providerProperties |= I32_FLAG(UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE);
2593 ut->a = length;
2594 ut->chunkContents = s;
2595 ut->chunkNativeStart = 0;
2596 ut->chunkNativeLimit = length>=0? length : 0;
2597 ut->chunkLength = (int32_t)ut->chunkNativeLimit;
2598 ut->chunkOffset = 0;
2599 ut->nativeIndexingLimit = ut->chunkLength;
2601 return ut;
2624 charIterTextClose(UText *ut) {
2628 CharacterIterator *ci = (CharacterIterator *)ut->r;
2630 ut->r = NULL;
2634 charIterTextLength(UText *ut) {
2635 return (int32_t)ut->a;
2639 charIterTextAccess(UText *ut, int64_t index, UBool forward) {
2640 CharacterIterator *ci = (CharacterIterator *)ut->context;
2645 } else if (clippedIndex>=ut->a) {
2646 clippedIndex=(int32_t)ut->a;
2652 } else if (forward && neededIndex==ut->a && neededIndex>0) {
2663 if (ut->chunkNativeStart == neededIndex) {
2666 } else if (ut->b == neededIndex) {
2668 buf = (UChar *)ut->p;
2669 } else if (ut->c == neededIndex) {
2671 buf = (UChar *)ut->q;
2676 buf = (UChar *)ut->p;
2677 if (ut->p == ut->chunkContents) {
2678 buf = (UChar *)ut->q;
2683 if (i+neededIndex > ut->a) {
2692 ut->chunkContents = buf;
2693 ut->chunkLength = CIBufSize;
2694 ut->chunkNativeStart = neededIndex;
2695 ut->chunkNativeLimit = neededIndex + CIBufSize;
2696 if (ut->chunkNativeLimit > ut->a) {
2697 ut->chunkNativeLimit = ut->a;
2698 ut->chunkLength = (int32_t)(ut->chunkNativeLimit)-(int32_t)(ut->chunkNativeStart);
2700 ut->nativeIndexingLimit = ut->chunkLength;
2701 U_ASSERT(ut->chunkOffset>=0 && ut->chunkOffset<=CIBufSize);
2703 ut->chunkOffset = clippedIndex - (int32_t)ut->chunkNativeStart;
2704 UBool success = (forward? ut->chunkOffset<ut->chunkLength : ut->chunkOffset>0);
2732 charIterTextExtract(UText *ut,
2744 int32_t length = (int32_t)ut->a;
2751 CharacterIterator *ci = (CharacterIterator *)ut->context;
2769 charIterTextAccess(ut, copyLimit, TRUE);
2796 utext_openCharacterIterator(UText *ut, CharacterIterator *ci, UErrorCode *status) {
2809 ut = utext_setup(ut, extraSpace, status);
2811 ut->pFuncs = &charIterFuncs;
2812 ut->context = ci;
2813 ut->providerProperties = 0;
2814 ut->a = ci->endIndex(); // Length of text
2815 ut->p = ut->pExtra; // First buffer
2816 ut->b = -1; // Native index of first buffer contents
2817 ut->q = (UChar*)ut->pExtra+CIBufSize; // Second buffer
2818 ut->c = -1; // Native index of second buffer contents
2826 ut->chunkContents = (UChar *)ut->p;
2827 ut->chunkNativeStart = -1;
2828 ut->chunkOffset = 1;
2829 ut->chunkNativeLimit = 0;
2830 ut->chunkLength = 0;
2831 ut->nativeIndexingLimit = ut->chunkOffset; // enables native indexing
2833 return ut;