/*
* setTrailingWSStart() sets the start index for a trailing
* run of WS in the line. This is necessary because we do not modify
* the paragraph's levels array that we just point into.
* Using trailingWSStart is another form of performing (L1).
*
* To make subsequent operations easier, we also include the run
* before the WS if it is at the paraLevel - we merge the two here.
*
* This function is called only from ubidi_setLine(), so pBiDi->paraLevel is
* set correctly for the line even when contextual multiple paragraphs.
*/
static void
setTrailingWSStart(UBiDi *pBiDi) {
/* pBiDi->direction!=UBIDI_MIXED */
const DirProp *dirProps=pBiDi->dirProps;
UBiDiLevel *levels=pBiDi->levels;
int32_t start=pBiDi->length;
UBiDiLevel paraLevel=pBiDi->paraLevel;
/* If the line is terminated by a block separator, all preceding WS etc...
are already set to paragraph level.
Setting trailingWSStart to pBidi->length will avoid changing the
level of B chars from 0 to paraLevel in ubidi_getLevels when
orderParagraphsLTR==TRUE.
*/
if(dirProps[start-1]==B) {
pBiDi->trailingWSStart=start; /* currently == pBiDi->length */
return;
}
/* go backwards across all WS, BN, explicit codes */
while(start>0 && DIRPROP_FLAG(dirProps[start-1])&MASK_WS) {
--start;
}
/* if the WS run can be merged with the previous run then do so here */
while(start>0 && levels[start-1]==paraLevel) {
--start;
}
pBiDi->trailingWSStart=start;
}
/* determine if the text is mixed-directional or single-directional */
static UBiDiDirection
directionFromFlags(Flags flags) {
/* if the text contains AN and neutrals, then some neutrals may become RTL */
if(!(flags&MASK_RTL || ((flags&DIRPROP_FLAG(AN)) && (flags&MASK_POSSIBLE_N)))) {
return UBIDI_LTR;
} else if(!(flags&MASK_LTR)) {
return UBIDI_RTL;
} else {
return UBIDI_MIXED;
}
}
/*
* setTrailingWSStart() sets the start index for a trailing
* run of WS in the line. This is necessary because we do not modify
* the paragraph's levels array that we just point into.
* Using trailingWSStart is another form of performing (L1).
*
* To make subsequent operations easier, we also include the run
* before the WS if it is at the paraLevel - we merge the two here.
*/
static void
setTrailingWSStart(UBiDi *pBiDi) {
/* pBiDi->direction!=UBIDI_MIXED */
const DirProp *dirProps=pBiDi->dirProps;
UBiDiLevel *levels=pBiDi->levels;
int32_t start=pBiDi->length;
UBiDiLevel paraLevel=pBiDi->paraLevel;
/* go backwards across all WS, BN, explicit codes */
while(start>0 && DIRPROP_FLAG(dirProps[start-1])&MASK_WS) {
--start;
}
/* if the WS run can be merged with the previous run then do so here */
while(start>0 && levels[start-1]==paraLevel) {
--start;
}
pBiDi->trailingWSStart=start;
}
/*
* Use a pre-specified embedding levels array:
*
* Adjust the directional properties for overrides (->LEVEL_OVERRIDE),
* ignore all explicit codes (X9),
* and check all the preset levels.
*
* Recalculate the flags to have them reflect the real properties
* after taking the explicit embeddings into account.
*/
static UBiDiDirection
checkExplicitLevels(UBiDi *pBiDi, UErrorCode *pErrorCode) {
const DirProp *dirProps=pBiDi->dirProps;
UBiDiLevel *levels=pBiDi->levels;
int32_t i, length=pBiDi->length;
Flags flags=0; /* collect all directionalities in the text */
UBiDiLevel level, paraLevel=pBiDi->paraLevel;
for(i=0; i<length; ++i) {
// dlf: we special case levels array for java, 0 means base level, not actually 0
if (levels[i] == 0) {
levels[i] = paraLevel;
}
level=levels[i];
if(level&UBIDI_LEVEL_OVERRIDE) {
/* keep the override flag in levels[i] but adjust the flags */
level&=~UBIDI_LEVEL_OVERRIDE; /* make the range check below simpler */
flags|=DIRPROP_FLAG_O(level);
} else {
/* set the flags */
flags|=DIRPROP_FLAG_E(level)|DIRPROP_FLAG(dirProps[i]);
}
if(level<paraLevel || UBIDI_MAX_EXPLICIT_LEVEL<level) {
/* level out of bounds */
*pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
return UBIDI_LTR;
}
}
if(flags&MASK_EMBEDDING) {
flags|=DIRPROP_FLAG_LR(pBiDi->paraLevel);
}
/* determine if the text is mixed-directional or single-directional */
pBiDi->flags=flags;
return directionFromFlags(flags);
}
U_CAPI int32_t U_EXPORT2
ubidi_writeReordered(UBiDi *pBiDi,
UChar *dest, int32_t destSize,
uint16_t options,
UErrorCode *pErrorCode) {
const UChar *text;
UChar *saveDest;
int32_t length, destCapacity;
int32_t run, runCount, logicalStart, runLength;
if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
return 0;
}
/* more error checking */
if( pBiDi==NULL ||
(text=pBiDi->text)==NULL || (length=pBiDi->length)<0 ||
destSize<0 || (destSize>0 && dest==NULL))
{
*pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
/* do input and output overlap? */
if( dest!=NULL &&
((text>=dest && text<dest+destSize) ||
(dest>=text && dest<text+pBiDi->originalLength)))
{
*pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
if(length==0) {
/* nothing to do */
return u_terminateUChars(dest, destSize, 0, pErrorCode);
}
runCount=ubidi_countRuns(pBiDi, pErrorCode);
if(U_FAILURE(*pErrorCode)) {
return 0;
}
/* destSize shrinks, later destination length=destCapacity-destSize */
saveDest=dest;
destCapacity=destSize;
/*
* Option "insert marks" implies UBIDI_INSERT_LRM_FOR_NUMERIC if the
* reordering mode (checked below) is appropriate.
*/
if(pBiDi->reorderingOptions & UBIDI_OPTION_INSERT_MARKS) {
options|=UBIDI_INSERT_LRM_FOR_NUMERIC;
options&=~UBIDI_REMOVE_BIDI_CONTROLS;
}
/*
* Option "remove controls" implies UBIDI_REMOVE_BIDI_CONTROLS
* and cancels UBIDI_INSERT_LRM_FOR_NUMERIC.
*/
if(pBiDi->reorderingOptions & UBIDI_OPTION_REMOVE_CONTROLS) {
options|=UBIDI_REMOVE_BIDI_CONTROLS;
options&=~UBIDI_INSERT_LRM_FOR_NUMERIC;
}
/*
* If we do not perform the "inverse BiDi" algorithm, then we
* don't need to insert any LRMs, and don't need to test for it.
*/
if((pBiDi->reorderingMode != UBIDI_REORDER_INVERSE_NUMBERS_AS_L) &&
(pBiDi->reorderingMode != UBIDI_REORDER_INVERSE_LIKE_DIRECT) &&
(pBiDi->reorderingMode != UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL) &&
(pBiDi->reorderingMode != UBIDI_REORDER_RUNS_ONLY)) {
options&=~UBIDI_INSERT_LRM_FOR_NUMERIC;
}
/*
* Iterate through all visual runs and copy the run text segments to
* the destination, according to the options.
*
* The tests for where to insert LRMs ignore the fact that there may be
* BN codes or non-BMP code points at the beginning and end of a run;
* they may insert LRMs unnecessarily but the tests are faster this way
* (this would have to be improved for UTF-8).
*
* Note that the only errors that are set by doWriteXY() are buffer overflow
* errors. Ignore them until the end, and continue for preflighting.
*/
if(!(options&UBIDI_OUTPUT_REVERSE)) {
/* forward output */
if(!(options&UBIDI_INSERT_LRM_FOR_NUMERIC)) {
/* do not insert BiDi controls */
for(run=0; run<runCount; ++run) {
if(UBIDI_LTR==ubidi_getVisualRun(pBiDi, run, &logicalStart, &runLength)) {
runLength=doWriteForward(text+logicalStart, runLength,
dest, destSize,
(uint16_t)(options&~UBIDI_DO_MIRRORING), pErrorCode);
} else {
runLength=doWriteReverse(text+logicalStart, runLength,
dest, destSize,
options, pErrorCode);
}
dest+=runLength;
destSize-=runLength;
}
} else {
/* insert BiDi controls for "inverse BiDi" */
const DirProp *dirProps=pBiDi->dirProps;
const UChar *src;
UChar uc;
UBiDiDirection dir;
int32_t markFlag;
for(run=0; run<runCount; ++run) {
dir=ubidi_getVisualRun(pBiDi, run, &logicalStart, &runLength);
src=text+logicalStart;
/* check if something relevant in insertPoints */
markFlag=pBiDi->runs[run].insertRemove;
if(markFlag<0) { /* BiDi controls count */
markFlag=0;
}
if(UBIDI_LTR==dir) {
if((pBiDi->isInverse) &&
(/*run>0 &&*/ dirProps[logicalStart]!=L)) {
markFlag |= LRM_BEFORE;
}
if (markFlag & LRM_BEFORE) {
uc=LRM_CHAR;
}
else if (markFlag & RLM_BEFORE) {
uc=RLM_CHAR;
}
else uc=0;
if(uc) {
if(destSize>0) {
*dest++=uc;
}
--destSize;
}
runLength=doWriteForward(src, runLength,
dest, destSize,
(uint16_t)(options&~UBIDI_DO_MIRRORING), pErrorCode);
dest+=runLength;
destSize-=runLength;
if((pBiDi->isInverse) &&
(/*run<runCount-1 &&*/ dirProps[logicalStart+runLength-1]!=L)) {
markFlag |= LRM_AFTER;
}
if (markFlag & LRM_AFTER) {
uc=LRM_CHAR;
}
else if (markFlag & RLM_AFTER) {
uc=RLM_CHAR;
}
else uc=0;
if(uc) {
if(destSize>0) {
*dest++=uc;
}
--destSize;
}
} else { /* RTL run */
if((pBiDi->isInverse) &&
(/*run>0 &&*/ !(MASK_R_AL&DIRPROP_FLAG(dirProps[logicalStart+runLength-1])))) {
markFlag |= RLM_BEFORE;
}
if (markFlag & LRM_BEFORE) {
uc=LRM_CHAR;
}
else if (markFlag & RLM_BEFORE) {
uc=RLM_CHAR;
}
else uc=0;
if(uc) {
if(destSize>0) {
*dest++=uc;
}
--destSize;
}
runLength=doWriteReverse(src, runLength,
dest, destSize,
options, pErrorCode);
dest+=runLength;
destSize-=runLength;
if((pBiDi->isInverse) &&
(/*run<runCount-1 &&*/ !(MASK_R_AL&DIRPROP_FLAG(dirProps[logicalStart])))) {
markFlag |= RLM_AFTER;
}
if (markFlag & LRM_AFTER) {
uc=LRM_CHAR;
}
else if (markFlag & RLM_AFTER) {
uc=RLM_CHAR;
}
else uc=0;
if(uc) {
if(destSize>0) {
*dest++=uc;
}
--destSize;
}
}
}
}
} else {
/* reverse output */
if(!(options&UBIDI_INSERT_LRM_FOR_NUMERIC)) {
/* do not insert BiDi controls */
for(run=runCount; --run>=0;) {
if(UBIDI_LTR==ubidi_getVisualRun(pBiDi, run, &logicalStart, &runLength)) {
runLength=doWriteReverse(text+logicalStart, runLength,
dest, destSize,
(uint16_t)(options&~UBIDI_DO_MIRRORING), pErrorCode);
} else {
runLength=doWriteForward(text+logicalStart, runLength,
dest, destSize,
options, pErrorCode);
}
dest+=runLength;
destSize-=runLength;
}
} else {
/* insert BiDi controls for "inverse BiDi" */
const DirProp *dirProps=pBiDi->dirProps;
const UChar *src;
UBiDiDirection dir;
for(run=runCount; --run>=0;) {
/* reverse output */
dir=ubidi_getVisualRun(pBiDi, run, &logicalStart, &runLength);
src=text+logicalStart;
if(UBIDI_LTR==dir) {
if(/*run<runCount-1 &&*/ dirProps[logicalStart+runLength-1]!=L) {
if(destSize>0) {
*dest++=LRM_CHAR;
}
--destSize;
}
runLength=doWriteReverse(src, runLength,
dest, destSize,
(uint16_t)(options&~UBIDI_DO_MIRRORING), pErrorCode);
dest+=runLength;
destSize-=runLength;
if(/*run>0 &&*/ dirProps[logicalStart]!=L) {
if(destSize>0) {
*dest++=LRM_CHAR;
}
--destSize;
}
} else {
if(/*run<runCount-1 &&*/ !(MASK_R_AL&DIRPROP_FLAG(dirProps[logicalStart]))) {
if(destSize>0) {
*dest++=RLM_CHAR;
}
--destSize;
}
runLength=doWriteForward(src, runLength,
dest, destSize,
options, pErrorCode);
dest+=runLength;
destSize-=runLength;
if(/*run>0 &&*/ !(MASK_R_AL&DIRPROP_FLAG(dirProps[logicalStart+runLength-1]))) {
if(destSize>0) {
*dest++=RLM_CHAR;
}
--destSize;
}
}
}
}
}
return u_terminateUChars(saveDest, destCapacity, destCapacity-destSize, pErrorCode);
}
static void
resolveImplicitLevels(UBiDi *pBiDi,
int32_t start, int32_t limit,
DirProp sor, DirProp eor) {
const DirProp *dirProps=pBiDi->dirProps;
UBiDiLevel *levels=pBiDi->levels;
int32_t i, next, neutralStart=-1;
DirProp prevDirProp, dirProp, nextDirProp, lastStrong, beforeNeutral=L;
UBiDiLevel numberLevel;
uint8_t historyOfEN;
/* initialize: current at sor, next at start (it is start<limit) */
next=start;
dirProp=lastStrong=sor;
nextDirProp=dirProps[next];
historyOfEN=0;
if(pBiDi->isInverse) {
/*
* For "inverse BiDi", we set the levels of numbers just like for
* regular L characters, plus a flag that ubidi_getRuns() will use
* to set a similar flag on the corresponding output run.
*/
numberLevel=levels[start];
if(numberLevel&1) {
++numberLevel;
}
} else {
/* normal BiDi: least greater even level */
numberLevel=(UBiDiLevel)((levels[start]+2)&~1);
}
/*
* In all steps of this implementation, BN and explicit embedding codes
* must be treated as if they didn't exist (X9).
* They will get levels set before a non-neutral character, and remain
* undefined before a neutral one, but adjustWSLevels() will take care
* of all of them.
*/
while(DIRPROP_FLAG(nextDirProp)&MASK_BN_EXPLICIT) {
if(++next<limit) {
nextDirProp=dirProps[next];
} else {
nextDirProp=eor;
break;
}
}
/*
* Note: at the end of this file, there is a prototype
* of a version of this function that uses a statetable
* at the core of this state machine.
* If you make changes to this state machine,
* please update that prototype as well.
*/
/* loop for entire run */
while(next<limit) {
/* advance */
prevDirProp=dirProp;
dirProp=nextDirProp;
i=next;
do {
if(++next<limit) {
nextDirProp=dirProps[next];
} else {
nextDirProp=eor;
break;
}
} while(DIRPROP_FLAG(nextDirProp)&MASK_BN_EXPLICIT);
historyOfEN<<=EN_SHIFT;
/* (W1..W7) */
switch(dirProp) {
case L:
lastStrong=L;
break;
case R:
lastStrong=R;
break;
case AL:
/* (W3) */
lastStrong=AL;
dirProp=R;
break;
case EN:
/* we have to set historyOfEN correctly */
if(lastStrong==AL) {
/* (W2) */
dirProp=AN;
} else {
if(lastStrong==L) {
/* (W7) */
dirProp=L;
}
/* this EN stays after (W2) and (W4) - at least before (W7) */
historyOfEN|=EN_ALL;
}
break;
case ES:
if( historyOfEN&PREV_EN_AFTER_W2 && /* previous was EN before (W4) */
nextDirProp==EN && lastStrong!=AL /* next is EN and (W2) won't make it AN */
) {
/* (W4) */
if(lastStrong!=L) {
dirProp=EN;
} else {
/* (W7) */
dirProp=L;
}
historyOfEN|=EN_AFTER_W4;
} else {
/* (W6) */
dirProp=ON;
}
break;
case CS:
if( historyOfEN&PREV_EN_AFTER_W2 && /* previous was EN before (W4) */
nextDirProp==EN && lastStrong!=AL /* next is EN and (W2) won't make it AN */
) {
/* (W4) */
if(lastStrong!=L) {
dirProp=EN;
} else {
/* (W7) */
dirProp=L;
}
historyOfEN|=EN_AFTER_W4;
} else if(prevDirProp==AN && /* previous was AN */
(nextDirProp==AN || /* next is AN */
(nextDirProp==EN && lastStrong==AL)) /* or (W2) will make it one */
) {
/* (W4) */
dirProp=AN;
} else {
/* (W6) */
dirProp=ON;
}
break;
case ET:
/* get sequence of ET; advance only next, not current, previous or historyOfEN */
if(next<limit) {
while(DIRPROP_FLAG(nextDirProp)&MASK_ET_NSM_BN /* (W1), (X9) */) {
if(++next<limit) {
nextDirProp=dirProps[next];
} else {
nextDirProp=eor;
break;
}
}
}
/* now process the sequence of ET like a single ET */
if((historyOfEN&PREV_EN_AFTER_W4) || /* previous was EN before (W5) */
(nextDirProp==EN && lastStrong!=AL) /* next is EN and (W2) won't make it AN */
) {
/* (W5) */
if(lastStrong!=L) {
dirProp=EN;
} else {
/* (W7) */
dirProp=L;
}
} else {
/* (W6) */
dirProp=ON;
}
/* apply the result of (W1), (W5)..(W7) to the entire sequence of ET */
break;
case NSM:
/* (W1) */
dirProp=prevDirProp;
/* set historyOfEN back to prevDirProp's historyOfEN */
historyOfEN>>=EN_SHIFT;
/*
* Technically, this should be done before the switch() in the form
* if(nextDirProp==NSM) {
* dirProps[next]=nextDirProp=dirProp;
* }
*
* - effectively one iteration ahead.
* However, whether the next dirProp is NSM or is equal to the current dirProp
* does not change the outcome of any condition in (W2)..(W7).
*/
break;
default:
break;
}
/* here, it is always [prev,this,next]dirProp!=BN; it may be next>i+1 */
/* perform (Nn) - here, only L, R, EN, AN, and neutrals are left */
/* for "inverse BiDi", treat neutrals like L */
/* this is one iteration late for the neutrals */
if(DIRPROP_FLAG(dirProp)&MASK_N) {
if(neutralStart<0) {
/* start of a sequence of neutrals */
neutralStart=i;
beforeNeutral=prevDirProp;
}
} else /* not a neutral, can be only one of { L, R, EN, AN } */ {
/*
* Note that all levels[] values are still the same at this
* point because this function is called for an entire
* same-level run.
* Therefore, we need to read only one actual level.
*/
UBiDiLevel level=levels[i];
if(neutralStart>=0) {
UBiDiLevel final;
/* end of a sequence of neutrals (dirProp is "afterNeutral") */
if(!(pBiDi->isInverse)) {
if(beforeNeutral==L) {
if(dirProp==L) {
final=0; /* make all neutrals L (N1) */
} else {
final=level; /* make all neutrals "e" (N2) */
}
} else /* beforeNeutral is one of { R, EN, AN } */ {
if(dirProp==L) {
static UBiDiDirection
resolveExplicitLevels(UBiDi *pBiDi) {
const DirProp *dirProps=pBiDi->dirProps;
UBiDiLevel *levels=pBiDi->levels;
int32_t i=0, length=pBiDi->length;
Flags flags=pBiDi->flags; /* collect all directionalities in the text */
DirProp dirProp;
UBiDiLevel level=pBiDi->paraLevel;
UBiDiDirection direction;
/* determine if the text is mixed-directional or single-directional */
direction=directionFromFlags(flags);
/* we may not need to resolve any explicit levels */
if(direction!=UBIDI_MIXED) {
/* not mixed directionality: levels don't matter - trailingWSStart will be 0 */
} else if(!(flags&MASK_EXPLICIT) || pBiDi->isInverse) {
/* mixed, but all characters are at the same embedding level */
/* or we are in "inverse BiDi" */
/* set all levels to the paragraph level */
for(i=0; i<length; ++i) {
levels[i]=level;
}
} else {
/* continue to perform (Xn) */
/* (X1) level is set for all codes, embeddingLevel keeps track of the push/pop operations */
/* both variables may carry the UBIDI_LEVEL_OVERRIDE flag to indicate the override status */
UBiDiLevel embeddingLevel=level, newLevel, stackTop=0;
UBiDiLevel stack[UBIDI_MAX_EXPLICIT_LEVEL]; /* we never push anything >=UBIDI_MAX_EXPLICIT_LEVEL */
uint32_t countOver60=0, countOver61=0; /* count overflows of explicit levels */
/* recalculate the flags */
flags=0;
/* since we assume that this is a single paragraph, we ignore (X8) */
for(i=0; i<length; ++i) {
dirProp=dirProps[i];
switch(dirProp) {
case LRE:
case LRO:
/* (X3, X5) */
newLevel=(UBiDiLevel)((embeddingLevel+2)&~(UBIDI_LEVEL_OVERRIDE|1)); /* least greater even level */
if(newLevel<=UBIDI_MAX_EXPLICIT_LEVEL) {
stack[stackTop]=embeddingLevel;
++stackTop;
embeddingLevel=newLevel;
if(dirProp==LRO) {
embeddingLevel|=UBIDI_LEVEL_OVERRIDE;
} else {
embeddingLevel&=~UBIDI_LEVEL_OVERRIDE;
}
} else if((embeddingLevel&~UBIDI_LEVEL_OVERRIDE)==UBIDI_MAX_EXPLICIT_LEVEL) {
++countOver61;
} else /* (embeddingLevel&~UBIDI_LEVEL_OVERRIDE)==UBIDI_MAX_EXPLICIT_LEVEL-1 */ {
++countOver60;
}
flags|=DIRPROP_FLAG(BN);
break;
case RLE:
case RLO:
/* (X2, X4) */
newLevel=(UBiDiLevel)(((embeddingLevel&~UBIDI_LEVEL_OVERRIDE)+1)|1); /* least greater odd level */
if(newLevel<=UBIDI_MAX_EXPLICIT_LEVEL) {
stack[stackTop]=embeddingLevel;
++stackTop;
embeddingLevel=newLevel;
if(dirProp==RLO) {
embeddingLevel|=UBIDI_LEVEL_OVERRIDE;
} else {
embeddingLevel&=~UBIDI_LEVEL_OVERRIDE;
}
} else {
++countOver61;
}
flags|=DIRPROP_FLAG(BN);
break;
case PDF:
/* (X7) */
/* handle all the overflow cases first */
if(countOver61>0) {
--countOver61;
} else if(countOver60>0 && (embeddingLevel&~UBIDI_LEVEL_OVERRIDE)!=UBIDI_MAX_EXPLICIT_LEVEL) {
/* handle LRx overflows from level 60 */
--countOver60;
} else if(stackTop>0) {
/* this is the pop operation; it also pops level 61 while countOver60>0 */
--stackTop;
embeddingLevel=stack[stackTop];
/* } else { (underflow) */
}
flags|=DIRPROP_FLAG(BN);
break;
case B:
/*
* We do not really expect to see a paragraph separator (B),
* but we should do something reasonable with it,
* especially at the end of the text.
*/
stackTop=0;
countOver60=countOver61=0;
embeddingLevel=level=pBiDi->paraLevel;
flags|=DIRPROP_FLAG(B);
break;
case BN:
/* BN, LRE, RLE, and PDF are supposed to be removed (X9) */
/* they will get their levels set correctly in adjustWSLevels() */
flags|=DIRPROP_FLAG(BN);
break;
default:
/* all other types get the "real" level */
if(level!=embeddingLevel) {
level=embeddingLevel;
if(level&UBIDI_LEVEL_OVERRIDE) {
flags|=DIRPROP_FLAG_O(level)|DIRPROP_FLAG_MULTI_RUNS;
} else {
flags|=DIRPROP_FLAG_E(level)|DIRPROP_FLAG_MULTI_RUNS;
}
}
if(!(level&UBIDI_LEVEL_OVERRIDE)) {
flags|=DIRPROP_FLAG(dirProp);
}
break;
}
/*
* We need to set reasonable levels even on BN codes and
* explicit codes because we will later look at same-level runs (X10).
*/
levels[i]=level;
}
if(flags&MASK_EMBEDDING) {
flags|=DIRPROP_FLAG_LR(pBiDi->paraLevel);
}
/* subsequently, ignore the explicit codes and BN (X9) */
/* again, determine if the text is mixed-directional or single-directional */
pBiDi->flags=flags;
direction=directionFromFlags(flags);
}
return direction;
}
/*
* Get the directional properties for the text,
* calculate the flags bit-set, and
* determine the partagraph level if necessary.
*/
static void
getDirProps(UBiDi *pBiDi, const UChar *text) {
DirProp *dirProps=pBiDi->dirPropsMemory; /* pBiDi->dirProps is const */
int32_t i=0, i0, i1, length=pBiDi->length;
Flags flags=0; /* collect all directionalities in the text */
UChar uchar;
DirProp dirProp;
if(IS_DEFAULT_LEVEL(pBiDi->paraLevel)) {
/* determine the paragraph level (P2..P3) */
for(;;) {
uchar=text[i];
if(!IS_FIRST_SURROGATE(uchar) || i+1==length || !IS_SECOND_SURROGATE(text[i+1])) {
/* not a surrogate pair */
flags|=DIRPROP_FLAG(dirProps[i]=dirProp=u_charDirection(uchar));
} else {
/* a surrogate pair */
dirProps[i++]=BN; /* first surrogate in the pair gets the BN type */
flags|=DIRPROP_FLAG(dirProps[i]=dirProp=u_surrogatePairDirection(uchar, text[i]))|DIRPROP_FLAG(BN);
}
++i;
if(dirProp==L) {
pBiDi->paraLevel=0;
break;
} else if(dirProp==R || dirProp==AL) {
pBiDi->paraLevel=1;
break;
} else if(i>=length) {
/*
* see comment in ubidi.h:
* the DEFAULT_XXX values are designed so that
* their bit 0 alone yields the intended default
*/
pBiDi->paraLevel&=1;
break;
}
}
} else {
flags|=DIRPROP_FLAG_LR(pBiDi->paraLevel);
}
/* get the rest of the directional properties and the flags bits */
while(i<length) {
uchar=text[i];
if(!IS_FIRST_SURROGATE(uchar) || i+1==length || !IS_SECOND_SURROGATE(text[i+1])) {
/* not a surrogate pair */
flags|=DIRPROP_FLAG(dirProps[i]=u_charDirection(uchar));
} else {
/* a surrogate pair */
dirProps[i++]=BN; /* first surrogate in the pair gets the BN type */
flags|=DIRPROP_FLAG(dirProps[i]=dirProp=u_surrogatePairDirection(uchar, text[i]))|DIRPROP_FLAG(BN);
}
++i;
}
if(flags&MASK_EMBEDDING) {
flags|=DIRPROP_FLAG_LR(pBiDi->paraLevel);
}
pBiDi->flags=flags;
}
U_CAPI void U_EXPORT2
ubidi_setPara(UBiDi *pBiDi, const UChar *text, int32_t length,
UBiDiLevel paraLevel, UBiDiLevel *embeddingLevels,
UErrorCode *pErrorCode) {
UBiDiDirection direction;
/* check the argument values */
if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
return;
} else if(pBiDi==NULL || text==NULL ||
((UBIDI_MAX_EXPLICIT_LEVEL<paraLevel) && !IS_DEFAULT_LEVEL(paraLevel)) ||
length<-1
) {
*pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
return;
}
if(length==-1) {
// length=u_strlen(text);
const UChar *p = text - 1;
while(*++p);
length = p - text;
}
/* initialize the UBiDi structure */
pBiDi->text=text;
pBiDi->length=length;
pBiDi->paraLevel=paraLevel;
pBiDi->direction=UBIDI_LTR;
pBiDi->trailingWSStart=length; /* the levels[] will reflect the WS run */
pBiDi->dirProps=NULL;
pBiDi->levels=NULL;
pBiDi->runs=NULL;
if(length==0) {
/*
* For an empty paragraph, create a UBiDi object with the paraLevel and
* the flags and the direction set but without allocating zero-length arrays.
* There is nothing more to do.
*/
if(IS_DEFAULT_LEVEL(paraLevel)) {
pBiDi->paraLevel&=1;
}
if(paraLevel&1) {
pBiDi->flags=DIRPROP_FLAG(R);
pBiDi->direction=UBIDI_RTL;
} else {
pBiDi->flags=DIRPROP_FLAG(L);
pBiDi->direction=UBIDI_LTR;
}
pBiDi->runCount=0;
return;
}
pBiDi->runCount=-1;
/*
* Get the directional properties,
* the flags bit-set, and
* determine the partagraph level if necessary.
*/
if(getDirPropsMemory(pBiDi, length)) {
pBiDi->dirProps=pBiDi->dirPropsMemory;
getDirProps(pBiDi, text);
} else {
*pErrorCode=U_MEMORY_ALLOCATION_ERROR;
return;
}
if (getLevelsMemory(pBiDi, length)) {
pBiDi->levels=pBiDi->levelsMemory;
/* are explicit levels specified? */
if(embeddingLevels==NULL) {
/* no: determine explicit levels according to the (Xn) rules */
direction=resolveExplicitLevels(pBiDi);
} else {
/* set BN for all explicit codes, check that all levels are paraLevel..UBIDI_MAX_EXPLICIT_LEVEL */
icu_memcpy(pBiDi->levels, embeddingLevels, length);
direction=checkExplicitLevels(pBiDi, pErrorCode);
if(U_FAILURE(*pErrorCode)) {
return;
}
}
} else {
*pErrorCode=U_MEMORY_ALLOCATION_ERROR;
return;
}
/*
* The steps after (X9) in the UBiDi algorithm are performed only if
* the paragraph text has mixed directionality!
*/
pBiDi->direction=direction;
switch(direction) {
case UBIDI_LTR:
/* make sure paraLevel is even */
pBiDi->paraLevel=(UBiDiLevel)((pBiDi->paraLevel+1)&~1);
/* all levels are implicitly at paraLevel (important for ubidi_getLevels()) */
pBiDi->trailingWSStart=0;
break;
case UBIDI_RTL:
/* make sure paraLevel is odd */
pBiDi->paraLevel|=1;
/* all levels are implicitly at paraLevel (important for ubidi_getLevels()) */
pBiDi->trailingWSStart=0;
break;
default:
/*
* If there are no external levels specified and there
* are no significant explicit level codes in the text,
* then we can treat the entire paragraph as one run.
* Otherwise, we need to perform the following rules on runs of
* the text with the same embedding levels. (X10)
* "Significant" explicit level codes are ones that actually
* affect non-BN characters.
* Examples for "insignificant" ones are empty embeddings
* LRE-PDF, LRE-RLE-PDF-PDF, etc.
*/
if(embeddingLevels==NULL && !(pBiDi->flags&DIRPROP_FLAG_MULTI_RUNS)) {
resolveImplicitLevels(pBiDi, 0, length,
GET_LR_FROM_LEVEL(pBiDi->paraLevel),
GET_LR_FROM_LEVEL(pBiDi->paraLevel));
} else {
/* sor, eor: start and end types of same-level-run */
UBiDiLevel *levels=pBiDi->levels;
int32_t start, limit=0;
UBiDiLevel level, nextLevel;
DirProp sor, eor;
/* determine the first sor and set eor to it because of the loop body (sor=eor there) */
level=pBiDi->paraLevel;
nextLevel=levels[0];
if(level<nextLevel) {
eor=GET_LR_FROM_LEVEL(nextLevel);
} else {
eor=GET_LR_FROM_LEVEL(level);
}
do {
/* determine start and limit of the run (end points just behind the run) */
/* the values for this run's start are the same as for the previous run's end */
sor=eor;
start=limit;
level=nextLevel;
/* search for the limit of this run */
while(++limit<length && levels[limit]==level) {}
/* get the correct level of the next run */
if(limit<length) {
nextLevel=levels[limit];
} else {
nextLevel=pBiDi->paraLevel;
}
/* determine eor from max(level, nextLevel); sor is last run's eor */
if((level&~UBIDI_LEVEL_OVERRIDE)<(nextLevel&~UBIDI_LEVEL_OVERRIDE)) {
eor=GET_LR_FROM_LEVEL(nextLevel);
} else {
eor=GET_LR_FROM_LEVEL(level);
}
/* if the run consists of overridden directional types, then there
are no implicit types to be resolved */
if(!(level&UBIDI_LEVEL_OVERRIDE)) {
resolveImplicitLevels(pBiDi, start, limit, sor, eor);
} else {
/* remove the UBIDI_LEVEL_OVERRIDE flags */
do {
levels[start++]&=~UBIDI_LEVEL_OVERRIDE;
} while(start<limit);
}
} while(limit<length);
}
/* reset the embedding levels for some non-graphic characters (L1), (X9) */
adjustWSLevels(pBiDi);
/* for "inverse BiDi", ubidi_getRuns() modifies the levels of numeric runs following RTL runs */
if(pBiDi->isInverse) {
if(!ubidi_getRuns(pBiDi)) {
*pErrorCode=U_MEMORY_ALLOCATION_ERROR;
return;
}
}
break;
}
}
static UBiDiDirection
checkExplicitLevels(UBiDi *pBiDi, UErrorCode *pErrorCode);
static UBiDiDirection
directionFromFlags(Flags flags);
static void
resolveImplicitLevels(UBiDi *pBiDi,
int32_t start, int32_t limit,
DirProp sor, DirProp eor);
static void
adjustWSLevels(UBiDi *pBiDi);
/* to avoid some conditional statements, use tiny constant arrays */
static const Flags flagLR[2]={ DIRPROP_FLAG(L), DIRPROP_FLAG(R) };
static const Flags flagE[2]={ DIRPROP_FLAG(LRE), DIRPROP_FLAG(RLE) };
static const Flags flagO[2]={ DIRPROP_FLAG(LRO), DIRPROP_FLAG(RLO) };
#define DIRPROP_FLAG_LR(level) flagLR[(level)&1]
#define DIRPROP_FLAG_E(level) flagE[(level)&1]
#define DIRPROP_FLAG_O(level) flagO[(level)&1]
/* UBiDi object management -------------------------------------------------- */
U_CAPI UBiDi * U_EXPORT2
ubidi_open(void)
{
UErrorCode errorCode=U_ZERO_ERROR;
return ubidi_openSized(0, 0, &errorCode);
}
