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;
895 utf8TextLength(UText *ut) {
896 if (ut->b < 0) {
899 const char *r = (const char *)ut->context + ut->c;
903 if ((r - (const char *)ut->context) < 0x7fffffff) {
904 ut->b = (int32_t)(r - (const char *)ut->context);
908 ut->b = 0x7fffffff;
910 ut->providerProperties &= ~I32_FLAG(UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE);
912 return ut->b;
921 utf8TextAccess(UText *ut, int64_t index, UBool forward) {
928 const uint8_t *s8=(const uint8_t *)ut->context;
930 int32_t length = ut->b; // Length of original utf-8
944 } else if (ix>=ut->c) {
949 while (ut->c<ix && s8[ut->c]!=0) {
950 ut->c++;
953 if (s8[ut->c] == 0) {
956 ix = ut->c;
957 ut->b = ut->c;
958 length = ut->c;
959 ut->providerProperties &= ~I32_FLAG(UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE);
968 if (ix==ut->chunkNativeLimit) {
974 ut->chunkOffset = ut->chunkLength;
979 UTF8Buf *altB = (UTF8Buf *)ut->q;
991 u8b = (UTF8Buf *)ut->q; // the alternate buffer
1000 if (ix == ut->chunkNativeLimit) {
1003 ut->chunkOffset = ut->chunkLength;
1016 if (ix<ut->chunkNativeStart || ix>=ut->chunkNativeLimit) {
1022 u8b = (UTF8Buf *)ut->p; // the current buffer
1024 ut->chunkOffset = u8b->mapToUChars[mapIndex] - u8b->bufStartIdx;
1035 if (ix==ut->chunkNativeStart) {
1041 ut->chunkOffset = 0;
1046 UTF8Buf *altB = (UTF8Buf *)ut->q;
1058 u8b = (UTF8Buf *)ut->q; // the alternate buffer
1079 if (ix<=ut->chunkNativeStart || ix>ut->chunkNativeLimit) {
1086 u8b = (UTF8Buf *)ut->p;
1088 ut->chunkOffset = u8b->mapToUChars[mapIndex] - u8b->bufStartIdx;
1089 if (ut->chunkOffset==0) {
1103 // The alternate buffer (ut->q) has the string data that was requested.
1107 u8b = (UTF8Buf *)ut->q;
1108 ut->q = ut->p;
1109 ut->p = u8b;
1110 ut->chunkContents = &u8b->buf[u8b->bufStartIdx];
1111 ut->chunkLength = u8b->bufLimitIdx - u8b->bufStartIdx;
1112 ut->chunkNativeStart = u8b->bufNativeStart;
1113 ut->chunkNativeLimit = u8b->bufNativeLimit;
1114 ut->nativeIndexingLimit = u8b->bufNILimit;
1124 ut->chunkOffset = u8b->mapToUChars[mapIndex] - u8b->bufStartIdx;
1139 u8b = (UTF8Buf *)ut->q;
1140 ut->q = ut->p;
1141 ut->p = u8b;
1142 ut->chunkContents = &u8b->buf[u8b->bufStartIdx];
1143 ut->chunkLength = u8b->bufLimitIdx - u8b->bufStartIdx;
1144 ut->chunkNativeStart = u8b->bufNativeStart;
1145 ut->chunkNativeLimit = u8b->bufNativeLimit;
1146 ut->nativeIndexingLimit = u8b->bufNILimit;
1152 ut->chunkOffset = ut->chunkLength;
1154 ut->chunkOffset = 0;
1164 u8b = (UTF8Buf *)ut->q;
1185 UTF8Buf *u8b = (UTF8Buf *)ut->q;
1186 ut->q = ut->p;
1187 ut->p = u8b;
1189 int32_t strLen = ut->b;
1262 ut->chunkContents = buf;
1263 ut->chunkOffset = 0;
1264 ut->chunkLength = u8b->bufLimitIdx;
1265 ut->chunkNativeStart = u8b->bufNativeStart;
1266 ut->chunkNativeLimit = u8b->bufNativeLimit;
1267 ut->nativeIndexingLimit = u8b->bufNILimit;
1271 if (nulTerminated && srcIx>ut->c) {
1272 ut->c = srcIx;
1276 ut->b = srcIx;
1277 ut->providerProperties &= ~I32_FLAG(UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE);
1289 if (ix != ut->b) {
1296 UTF8Buf *u8b = (UTF8Buf *)ut->q;
1297 ut->q = ut->p;
1298 ut->p = u8b;
1374 ut->chunkContents = &buf[u8b->bufStartIdx];
1375 ut->chunkLength = u8b->bufLimitIdx - u8b->bufStartIdx;
1376 ut->chunkOffset = ut->chunkLength;
1377 ut->chunkNativeStart = u8b->bufNativeStart;
1378 ut->chunkNativeLimit = u8b->bufNativeLimit;
1379 ut->nativeIndexingLimit = u8b->bufNILimit;
1455 utf8TextExtract(UText *ut,
1466 int32_t length = ut->b;
1479 const uint8_t *buf = (const uint8_t *)ut->context;
1481 if (start32 < ut->chunkNativeLimit) {
1490 if (limit32 < ut->chunkNativeLimit) {
1502 (const char *)ut->context+start32, limit32-start32,
1504 utf8TextAccess(ut, limit32, TRUE);
1513 utf8TextMapOffsetToNative(const UText *ut) {
1515 UTF8Buf *u8b = (UTF8Buf *)ut->p;
1516 U_ASSERT(ut->chunkOffset>ut->nativeIndexingLimit && ut->chunkOffset<=ut->chunkLength);
1517 int32_t nativeOffset = u8b->mapToNative[ut->chunkOffset + u8b->bufStartIdx] + u8b->toUCharsMapStart;
1518 U_ASSERT(nativeOffset >= ut->chunkNativeStart && nativeOffset <= ut->chunkNativeLimit);
1526 utf8TextMapIndexToUTF16(const UText *ut, int64_t index64) {
1529 UTF8Buf *u8b = (UTF8Buf *)ut->p;
1530 U_ASSERT(index>=ut->chunkNativeStart+ut->nativeIndexingLimit);
1531 U_ASSERT(index<=ut->chunkNativeLimit);
1534 U_ASSERT(offset>=0 && offset<=ut->chunkLength);
1569 utf8TextClose(UText *ut) {
1573 if (ut->providerProperties & I32_FLAG(UTEXT_PROVIDER_OWNS_TEXT)) {
1574 char *s = (char *)ut->context;
1576 ut->context = NULL;
1605 utext_openUTF8(UText *ut, const char *s, int64_t length, UErrorCode *status) {
1618 ut = utext_setup(ut, sizeof(UTF8Buf) * 2, status);
1620 return ut;
1623 ut->pFuncs = &utf8Funcs;
1624 ut->context = s;
1625 ut->b = (int32_t)length;
1626 ut->c = (int32_t)length;
1627 if (ut->c < 0) {
1628 ut->c = 0;
1629 ut->providerProperties |= I32_FLAG(UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE);
1631 ut->p = ut->pExtra;
1632 ut->q = (char *)ut->pExtra + sizeof(UTF8Buf);
1633 return ut;
1694 repTextClose(UText *ut) {
1698 if (ut->providerProperties & I32_FLAG(UTEXT_PROVIDER_OWNS_TEXT)) {
1699 Replaceable *rep = (Replaceable *)ut->context;
1701 ut->context = NULL;
1707 repTextLength(UText *ut) {
1708 const Replaceable *replSrc = (const Replaceable *)ut->context;
1715 repTextAccess(UText *ut, int64_t index, UBool forward) {
1716 const Replaceable *rep=(const Replaceable *)ut->context;
1734 if (index32>=ut->chunkNativeStart && index32<ut->chunkNativeLimit) {
1736 ut->chunkOffset = (int32_t)(index - ut->chunkNativeStart);
1739 if (index32>=length && ut->chunkNativeLimit==length) {
1742 ut->chunkOffset = length - (int32_t)ut->chunkNativeStart;
1746 ut->chunkNativeLimit = index + REP_TEXT_CHUNK_SIZE - 1;
1751 if(ut->chunkNativeLimit > length) {
1752 ut->chunkNativeLimit = length;
1755 ut->chunkNativeStart = ut->chunkNativeLimit - REP_TEXT_CHUNK_SIZE;
1756 if(ut->chunkNativeStart < 0) {
1757 ut->chunkNativeStart = 0;
1761 if (index32>ut->chunkNativeStart && index32<=ut->chunkNativeLimit) {
1763 ut->chunkOffset = index32 - (int32_t)ut->chunkNativeStart;
1766 if (index32==0 && ut->chunkNativeStart==0) {
1769 ut->chunkOffset = 0;
1779 ut->chunkNativeStart = index32 + 1 - REP_TEXT_CHUNK_SIZE;
1780 if (ut->chunkNativeStart < 0) {
1781 ut->chunkNativeStart = 0;
1784 ut->chunkNativeLimit = index32 + 1;
1785 if (ut->chunkNativeLimit > length) {
1786 ut->chunkNativeLimit = length;
1791 ReplExtra *ex = (ReplExtra *)ut->pExtra;
1794 rep->extractBetween((int32_t)ut->chunkNativeStart, (int32_t)ut->chunkNativeLimit, buffer);
1796 ut->chunkContents = ex->s;
1797 ut->chunkLength = (int32_t)(ut->chunkNativeLimit - ut->chunkNativeStart);
1798 ut->chunkOffset = (int32_t)(index32 - ut->chunkNativeStart);
1802 if (ut->chunkNativeLimit < length &&
1803 U16_IS_LEAD(ex->s[ut->chunkLength-1])) {
1804 ut->chunkLength--;
1805 ut->chunkNativeLimit--;
1806 if (ut->chunkOffset > ut->chunkLength) {
1807 ut->chunkOffset = ut->chunkLength;
1813 if(ut->chunkNativeStart>0 && U16_IS_TRAIL(ex->s[0])) {
1814 ++(ut->chunkContents);
1815 ++(ut->chunkNativeStart);
1816 --(ut->chunkLength);
1817 --(ut->chunkOffset);
1821 U16_SET_CP_START(ut->chunkContents, 0, ut->chunkOffset);
1824 ut->nativeIndexingLimit = ut->chunkLength;
1832 repTextExtract(UText *ut,
1836 const Replaceable *rep=(const Replaceable *)ut->context;
1869 repTextAccess(ut, limit32, TRUE);
1875 repTextReplace(UText *ut,
1879 Replaceable *rep=(Replaceable *)ut->context;
1917 if (ut->chunkNativeLimit > start32) {
1920 invalidateChunk(ut);
1925 repTextAccess(ut, newIndexPos, TRUE);
1932 repTextCopy(UText *ut,
1938 Replaceable *rep=(Replaceable *)ut->context;
1976 if (firstAffectedIndex < ut->chunkNativeLimit) {
1978 invalidateChunk(ut);
1989 repTextAccess(ut, nativeIterIndex, TRUE);
2012 utext_openReplaceable(UText *ut, Replaceable *rep, UErrorCode *status)
2021 ut = utext_setup(ut, sizeof(ReplExtra), status);
2023 ut->providerProperties = I32_FLAG(UTEXT_PROVIDER_WRITABLE);
2025 ut->providerProperties |=I32_FLAG(UTEXT_PROVIDER_HAS_META_DATA);
2028 ut->pFuncs = &repFuncs;
2029 ut->context = rep;
2030 return ut;
2080 unistrTextClose(UText *ut) {
2084 if (ut->providerProperties & I32_FLAG(UTEXT_PROVIDER_OWNS_TEXT)) {
2085 UnicodeString *str = (UnicodeString *)ut->context;
2087 ut->context = NULL;
2099 unistrTextAccess(UText *ut, int64_t index, UBool forward) {
2100 int32_t length = ut->chunkLength;
2101 ut->chunkOffset = pinIndex(index, length);
2148 unistrTextReplace(UText *ut,
2152 UnicodeString *us=(UnicodeString *)ut->context;
2180 ut->chunkContents = us->getBuffer();
2181 ut->chunkLength = newLength;
2182 ut->chunkNativeLimit = newLength;
2183 ut->nativeIndexingLimit = newLength;
2187 ut->chunkOffset = limit32 + lengthDelta;
2193 unistrTextCopy(UText *ut,
2198 UnicodeString *us=(UnicodeString *)ut->context;
2227 ut->chunkContents = us->getBuffer();
2230 ut->chunkLength += limit32-start32;
2231 ut->chunkNativeLimit = ut->chunkLength;
2232 ut->nativeIndexingLimit = ut->chunkLength;
2236 ut->chunkOffset = destIndex32+limit32-start32;
2238 ut->chunkOffset = destIndex32;
2267 utext_openUnicodeString(UText *ut, UnicodeString *s, UErrorCode *status) {
2268 ut = utext_openConstUnicodeString(ut, s, status);
2270 ut->providerProperties |= I32_FLAG(UTEXT_PROVIDER_WRITABLE);
2272 return ut;
2278 utext_openConstUnicodeString(UText *ut, const UnicodeString *s, UErrorCode *status) {
2282 utext_openUChars(ut, NULL, 0, status);
2284 return ut;
2286 ut = utext_setup(ut, 0, status);
2291 ut->pFuncs = &unistrFuncs;
2292 ut->context = s;
2293 ut->providerProperties = I32_FLAG(UTEXT_PROVIDER_STABLE_CHUNKS);
2294 ut->chunkContents = s->getBuffer();
2295 ut->chunkLength = s->length();
2296 ut->chunkNativeStart = 0;
2297 ut->chunkNativeLimit = ut->chunkLength;
2298 ut->nativeIndexingLimit = ut->chunkLength;
2300 return ut;
2352 ucstrTextClose(UText *ut) {
2356 if (ut->providerProperties & I32_FLAG(UTEXT_PROVIDER_OWNS_TEXT)) {
2357 UChar *s = (UChar *)ut->context;
2359 ut->context = NULL;
2366 ucstrTextLength(UText *ut) {
2367 if (ut->a < 0) {
2371 const UChar *str = (const UChar *)ut->context;
2373 if (str[ut->chunkNativeLimit] == 0) {
2376 ut->chunkNativeLimit++;
2378 ut->a = ut->chunkNativeLimit;
2379 ut->chunkLength = (int32_t)ut->chunkNativeLimit;
2380 ut->nativeIndexingLimit = ut->chunkLength;
2381 ut->providerProperties &= ~I32_FLAG(UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE);
2383 return ut->a;
2388 ucstrTextAccess(UText *ut, int64_t index, UBool forward) {
2389 const UChar *str = (const UChar *)ut->context;
2395 } else if (index < ut->chunkNativeLimit) {
2399 } else if (ut->a >= 0) {
2402 index = ut->a;
2414 int32_t chunkLimit = (int32_t)ut->chunkNativeLimit;
2419 ut->a = chunkLimit;
2420 ut->chunkLength = chunkLimit;
2421 ut->nativeIndexingLimit = chunkLimit;
2428 ut->chunkNativeLimit = chunkLimit;
2429 ut->providerProperties &= ~I32_FLAG(UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE);
2439 ut->a = chunkLimit;
2440 ut->chunkLength = chunkLimit;
2441 ut->nativeIndexingLimit = chunkLimit;
2445 ut->chunkNativeLimit = chunkLimit;
2446 ut->providerProperties &= ~I32_FLAG(UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE);
2458 // ut->a being < 0.
2459 ut->chunkNativeLimit = chunkLimit;
2460 ut->nativeIndexingLimit = chunkLimit;
2461 ut->chunkLength = chunkLimit;
2467 ut->chunkOffset = (int32_t)index;
2470 UBool retVal = (forward && index<ut->chunkNativeLimit) || (!forward && index>0);
2477 ucstrTextExtract(UText *ut,
2490 //const UChar *s=(const UChar *)ut->context;
2499 ucstrTextAccess(ut, start, TRUE);
2500 const UChar *s=ut->chunkContents;
2501 start32 = ut->chunkOffset;
2503 int32_t strLength=(int32_t)ut->a;
2513 ut->a = si; // set string length for this UText
2514 ut->chunkNativeLimit = si;
2515 ut->chunkLength = si;
2516 ut->nativeIndexingLimit = si;
2548 ut->chunkOffset = uprv_min(strLength, start32 + destCapacity);
2579 utext_openUChars(UText *ut, const UChar *s, int64_t length, UErrorCode *status) {
2590 ut = utext_setup(ut, 0, status);
2592 ut->pFuncs = &ucstrFuncs;
2593 ut->context = s;
2594 ut->providerProperties = I32_FLAG(UTEXT_PROVIDER_STABLE_CHUNKS);
2596 ut->providerProperties |= I32_FLAG(UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE);
2598 ut->a = length;
2599 ut->chunkContents = s;
2600 ut->chunkNativeStart = 0;
2601 ut->chunkNativeLimit = length>=0? length : 0;
2602 ut->chunkLength = (int32_t)ut->chunkNativeLimit;
2603 ut->chunkOffset = 0;
2604 ut->nativeIndexingLimit = ut->chunkLength;
2606 return ut;
2629 charIterTextClose(UText *ut) {
2633 CharacterIterator *ci = (CharacterIterator *)ut->r;
2635 ut->r = NULL;
2639 charIterTextLength(UText *ut) {
2640 return (int32_t)ut->a;
2644 charIterTextAccess(UText *ut, int64_t index, UBool forward) {
2645 CharacterIterator *ci = (CharacterIterator *)ut->context;
2650 } else if (clippedIndex>=ut->a) {
2651 clippedIndex=(int32_t)ut->a;
2657 } else if (forward && neededIndex==ut->a && neededIndex>0) {
2668 if (ut->chunkNativeStart == neededIndex) {
2671 } else if (ut->b == neededIndex) {
2673 buf = (UChar *)ut->p;
2674 } else if (ut->c == neededIndex) {
2676 buf = (UChar *)ut->q;
2681 buf = (UChar *)ut->p;
2682 if (ut->p == ut->chunkContents) {
2683 buf = (UChar *)ut->q;
2688 if (i+neededIndex > ut->a) {
2697 ut->chunkContents = buf;
2698 ut->chunkLength = CIBufSize;
2699 ut->chunkNativeStart = neededIndex;
2700 ut->chunkNativeLimit = neededIndex + CIBufSize;
2701 if (ut->chunkNativeLimit > ut->a) {
2702 ut->chunkNativeLimit = ut->a;
2703 ut->chunkLength = (int32_t)(ut->chunkNativeLimit)-(int32_t)(ut->chunkNativeStart);
2705 ut->nativeIndexingLimit = ut->chunkLength;
2706 U_ASSERT(ut->chunkOffset>=0 && ut->chunkOffset<=CIBufSize);
2708 ut->chunkOffset = clippedIndex - (int32_t)ut->chunkNativeStart;
2709 UBool success = (forward? ut->chunkOffset<ut->chunkLength : ut->chunkOffset>0);
2737 charIterTextExtract(UText *ut,
2749 int32_t length = (int32_t)ut->a;
2756 CharacterIterator *ci = (CharacterIterator *)ut->context;
2774 charIterTextAccess(ut, copyLimit, TRUE);
2801 utext_openCharacterIterator(UText *ut, CharacterIterator *ci, UErrorCode *status) {
2814 ut = utext_setup(ut, extraSpace, status);
2816 ut->pFuncs = &charIterFuncs;
2817 ut->context = ci;
2818 ut->providerProperties = 0;
2819 ut->a = ci->endIndex(); // Length of text
2820 ut->p = ut->pExtra; // First buffer
2821 ut->b = -1; // Native index of first buffer contents
2822 ut->q = (UChar*)ut->pExtra+CIBufSize; // Second buffer
2823 ut->c = -1; // Native index of second buffer contents
2831 ut->chunkContents = (UChar *)ut->p;
2832 ut->chunkNativeStart = -1;
2833 ut->chunkOffset = 1;
2834 ut->chunkNativeLimit = 0;
2835 ut->chunkLength = 0;
2836 ut->nativeIndexingLimit = ut->chunkOffset; // enables native indexing
2838 return ut;