/* * 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); }