U_CAPI int32_t U_EXPORT2
ubidi_countRuns(UBiDi *pBiDi, UErrorCode *pErrorCode) {
RETURN_IF_NULL_OR_FAILING_ERRCODE(pErrorCode, -1);
RETURN_IF_NOT_VALID_PARA_OR_LINE(pBiDi, *pErrorCode, -1);
ubidi_getRuns(pBiDi, pErrorCode);
if(U_FAILURE(*pErrorCode)) {
return -1;
}
return pBiDi->runCount;
}
U_CAPI const UBiDiLevel * U_EXPORT2
ubidi_getLevels(UBiDi * pBiDi, UErrorCode * pErrorCode)
{
int32_t start, length;
RETURN_IF_NULL_OR_FAILING_ERRCODE(pErrorCode, NULL);
RETURN_IF_NOT_VALID_PARA_OR_LINE(pBiDi, *pErrorCode, NULL);
if ((length = pBiDi->length) <= 0)
{
*pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
return NULL;
}
if ((start = pBiDi->trailingWSStart) == length)
{
/* the current levels array reflects the WS run */
return pBiDi->levels;
}
/*
* After the previous if(), we know that the levels array
* has an implicit trailing WS run and therefore does not fully
* reflect itself all the levels.
* This must be a UBiDi object for a line, and
* we need to create a new levels array.
*/
if (getLevelsMemory(pBiDi, length))
{
UBiDiLevel * levels = pBiDi->levelsMemory;
if (start > 0 && levels != pBiDi->levels)
{
uprv_memcpy(levels, pBiDi->levels, start);
}
/* pBiDi->paraLevel is ok even if contextual multiple paragraphs,
since pBidi is a line object */
uprv_memset(levels + start, pBiDi->paraLevel, length - start);
/* this new levels array is set for the line and reflects the WS run */
pBiDi->trailingWSStart = length;
return pBiDi->levels = levels;
}
else
{
/* out of memory */
*pErrorCode = U_MEMORY_ALLOCATION_ERROR;
return NULL;
}
}
U_CAPI int32_t U_EXPORT2
ubidi_getLogicalIndex(UBiDi *pBiDi, int32_t visualIndex, UErrorCode *pErrorCode) {
Run *runs;
int32_t i, runCount, start;
RETURN_IF_NULL_OR_FAILING_ERRCODE(pErrorCode, -1);
RETURN_IF_NOT_VALID_PARA_OR_LINE(pBiDi, *pErrorCode, -1);
RETURN_IF_BAD_RANGE(visualIndex, 0, pBiDi->resultLength, *pErrorCode, -1);
/* we can do the trivial cases without the runs array */
if(pBiDi->insertPoints.size==0 && pBiDi->controlCount==0) {
if(pBiDi->direction==UBIDI_LTR) {
return visualIndex;
}
else if(pBiDi->direction==UBIDI_RTL) {
return pBiDi->length-visualIndex-1;
}
}
if(!ubidi_getRuns(pBiDi, pErrorCode)) {
*pErrorCode=U_MEMORY_ALLOCATION_ERROR;
return -1;
}
runs=pBiDi->runs;
runCount=pBiDi->runCount;
if(pBiDi->insertPoints.size>0) {
/* handle inserted LRM/RLM */
int32_t markFound=0, insertRemove;
int32_t visualStart=0, length;
runs=pBiDi->runs;
/* subtract number of marks until visual index */
for(i=0; ; i++, visualStart+=length) {
length=runs[i].visualLimit-visualStart;
insertRemove=runs[i].insertRemove;
if(insertRemove&(LRM_BEFORE|RLM_BEFORE)) {
if(visualIndex<=(visualStart+markFound)) {
return UBIDI_MAP_NOWHERE;
}
markFound++;
}
/* is adjusted visual index within this run? */
if(visualIndex<(runs[i].visualLimit+markFound)) {
visualIndex-=markFound;
break;
}
if(insertRemove&(LRM_AFTER|RLM_AFTER)) {
if(visualIndex==(visualStart+length+markFound)) {
return UBIDI_MAP_NOWHERE;
}
markFound++;
}
}
}
else if(pBiDi->controlCount>0) {
/* handle removed BiDi control characters */
int32_t controlFound=0, insertRemove, length;
int32_t logicalStart, logicalEnd, visualStart=0, j, k;
UChar uchar;
UBool evenRun;
/* add number of controls until visual index */
for(i=0; ; i++, visualStart+=length) {
length=runs[i].visualLimit-visualStart;
insertRemove=runs[i].insertRemove;
/* is adjusted visual index beyond current run? */
if(visualIndex>=(runs[i].visualLimit-controlFound+insertRemove)) {
controlFound-=insertRemove;
continue;
}
/* adjusted visual index is within current run */
if(insertRemove==0) {
visualIndex+=controlFound;
break;
}
/* count non-control chars until visualIndex */
logicalStart=runs[i].logicalStart;
evenRun=IS_EVEN_RUN(logicalStart);
REMOVE_ODD_BIT(logicalStart);
logicalEnd=logicalStart+length-1;
for(j=0; j<length; j++) {
k= evenRun ? logicalStart+j : logicalEnd-j;
uchar=pBiDi->text[k];
if(IS_BIDI_CONTROL_CHAR(uchar)) {
controlFound++;
}
if((visualIndex+controlFound)==(visualStart+j)) {
break;
}
}
visualIndex+=controlFound;
break;
}
}
/* handle all cases */
if(runCount<=10) {
/* linear search for the run */
for(i=0; visualIndex>=runs[i].visualLimit; ++i) {}
} else {
/* binary search for the run */
int32_t begin=0, limit=runCount;
/* the middle if() is guaranteed to find the run, we don't need a loop limit */
for(;;) {
i=(begin+limit)/2;
if(visualIndex>=runs[i].visualLimit) {
begin=i+1;
} else if(i==0 || visualIndex>=runs[i-1].visualLimit) {
break;
} else {
limit=i;
}
}
}
start=runs[i].logicalStart;
if(IS_EVEN_RUN(start)) {
/* LTR */
/* the offset in runs[i] is visualIndex-runs[i-1].visualLimit */
if(i>0) {
visualIndex-=runs[i-1].visualLimit;
}
return start+visualIndex;
} else {
/* RTL */
return GET_INDEX(start)+runs[i].visualLimit-visualIndex-1;
}
}
U_CAPI int32_t U_EXPORT2
ubidi_getVisualIndex(UBiDi *pBiDi, int32_t logicalIndex, UErrorCode *pErrorCode) {
int32_t visualIndex=UBIDI_MAP_NOWHERE;
RETURN_IF_NULL_OR_FAILING_ERRCODE(pErrorCode, -1);
RETURN_IF_NOT_VALID_PARA_OR_LINE(pBiDi, *pErrorCode, -1);
RETURN_IF_BAD_RANGE(logicalIndex, 0, pBiDi->length, *pErrorCode, -1);
/* we can do the trivial cases without the runs array */
switch(pBiDi->direction) {
case UBIDI_LTR:
visualIndex=logicalIndex;
break;
case UBIDI_RTL:
visualIndex=pBiDi->length-logicalIndex-1;
break;
default:
if(!ubidi_getRuns(pBiDi, pErrorCode)) {
*pErrorCode=U_MEMORY_ALLOCATION_ERROR;
return -1;
} else {
Run *runs=pBiDi->runs;
int32_t i, visualStart=0, offset, length;
/* linear search for the run, search on the visual runs */
for(i=0; i<pBiDi->runCount; ++i) {
length=runs[i].visualLimit-visualStart;
offset=logicalIndex-GET_INDEX(runs[i].logicalStart);
if(offset>=0 && offset<length) {
if(IS_EVEN_RUN(runs[i].logicalStart)) {
/* LTR */
visualIndex=visualStart+offset;
} else {
/* RTL */
visualIndex=visualStart+length-offset-1;
}
break; /* exit for loop */
}
visualStart+=length;
}
if(i>=pBiDi->runCount) {
return UBIDI_MAP_NOWHERE;
}
}
}
if(pBiDi->insertPoints.size>0) {
/* add the number of added marks until the calculated visual index */
Run *runs=pBiDi->runs;
int32_t i, length, insertRemove;
int32_t visualStart=0, markFound=0;
for(i=0; ; i++, visualStart+=length) {
length=runs[i].visualLimit-visualStart;
insertRemove=runs[i].insertRemove;
if(insertRemove & (LRM_BEFORE|RLM_BEFORE)) {
markFound++;
}
/* is it the run containing the visual index? */
if(visualIndex<runs[i].visualLimit) {
return visualIndex+markFound;
}
if(insertRemove & (LRM_AFTER|RLM_AFTER)) {
markFound++;
}
}
}
else if(pBiDi->controlCount>0) {
/* subtract the number of controls until the calculated visual index */
Run *runs=pBiDi->runs;
int32_t i, j, start, limit, length, insertRemove;
int32_t visualStart=0, controlFound=0;
UChar uchar=pBiDi->text[logicalIndex];
/* is the logical index pointing to a control ? */
if(IS_BIDI_CONTROL_CHAR(uchar)) {
return UBIDI_MAP_NOWHERE;
}
/* loop on runs */
for(i=0; ; i++, visualStart+=length) {
length=runs[i].visualLimit-visualStart;
insertRemove=runs[i].insertRemove;
/* calculated visual index is beyond this run? */
if(visualIndex>=runs[i].visualLimit) {
controlFound-=insertRemove;
continue;
}
/* calculated visual index must be within current run */
if(insertRemove==0) {
return visualIndex-controlFound;
}
if(IS_EVEN_RUN(runs[i].logicalStart)) {
/* LTR: check from run start to logical index */
start=runs[i].logicalStart;
limit=logicalIndex;
} else {
/* RTL: check from logical index to run end */
start=logicalIndex+1;
limit=GET_INDEX(runs[i].logicalStart)+length;
}
for(j=start; j<limit; j++) {
uchar=pBiDi->text[j];
if(IS_BIDI_CONTROL_CHAR(uchar)) {
controlFound++;
}
}
return visualIndex-controlFound;
}
}
return visualIndex;
}
