| // © 2016 and later: Unicode, Inc. and others. | |
| // License & terms of use: http://www.unicode.org/copyright.html | |
| /* | |
| ****************************************************************************** | |
| * | |
| * Copyright (C) 1999-2015, International Business Machines | |
| * Corporation and others. All Rights Reserved. | |
| * | |
| ****************************************************************************** | |
| * file name: ubidi.c | |
| * encoding: UTF-8 | |
| * tab size: 8 (not used) | |
| * indentation:4 | |
| * | |
| * created on: 1999jul27 | |
| * created by: Markus W. Scherer, updated by Matitiahu Allouche | |
| * | |
| */ | |
| #if defined(STARBOARD) | |
| #include "starboard/client_porting/poem/assert_poem.h" | |
| #endif // defined(STARBOARD) | |
| #include "cmemory.h" | |
| #include "unicode/utypes.h" | |
| #include "unicode/ustring.h" | |
| #include "unicode/uchar.h" | |
| #include "unicode/ubidi.h" | |
| #include "unicode/utf16.h" | |
| #include "ubidi_props.h" | |
| #include "ubidiimp.h" | |
| #include "uassert.h" | |
| /* | |
| * General implementation notes: | |
| * | |
| * Throughout the implementation, there are comments like (W2) that refer to | |
| * rules of the BiDi algorithm, in this example to the second rule of the | |
| * resolution of weak types. | |
| * | |
| * For handling surrogate pairs, where two UChar's form one "abstract" (or UTF-32) | |
| * character according to UTF-16, the second UChar gets the directional property of | |
| * the entire character assigned, while the first one gets a BN, a boundary | |
| * neutral, type, which is ignored by most of the algorithm according to | |
| * rule (X9) and the implementation suggestions of the BiDi algorithm. | |
| * | |
| * Later, adjustWSLevels() will set the level for each BN to that of the | |
| * following character (UChar), which results in surrogate pairs getting the | |
| * same level on each of their surrogates. | |
| * | |
| * In a UTF-8 implementation, the same thing could be done: the last byte of | |
| * a multi-byte sequence would get the "real" property, while all previous | |
| * bytes of that sequence would get BN. | |
| * | |
| * It is not possible to assign all those parts of a character the same real | |
| * property because this would fail in the resolution of weak types with rules | |
| * that look at immediately surrounding types. | |
| * | |
| * As a related topic, this implementation does not remove Boundary Neutral | |
| * types from the input, but ignores them wherever this is relevant. | |
| * For example, the loop for the resolution of the weak types reads | |
| * types until it finds a non-BN. | |
| * Also, explicit embedding codes are neither changed into BN nor removed. | |
| * They are only treated the same way real BNs are. | |
| * As stated before, adjustWSLevels() takes care of them at the end. | |
| * For the purpose of conformance, the levels of all these codes | |
| * do not matter. | |
| * | |
| * Note that this implementation modifies the dirProps | |
| * after the initial setup, when applying X5c (replace FSI by LRI or RLI), | |
| * X6, N0 (replace paired brackets by L or R). | |
| * | |
| * In this implementation, the resolution of weak types (W1 to W6), | |
| * neutrals (N1 and N2), and the assignment of the resolved level (In) | |
| * are all done in one single loop, in resolveImplicitLevels(). | |
| * Changes of dirProp values are done on the fly, without writing | |
| * them back to the dirProps array. | |
| * | |
| * | |
| * This implementation contains code that allows to bypass steps of the | |
| * algorithm that are not needed on the specific paragraph | |
| * in order to speed up the most common cases considerably, | |
| * like text that is entirely LTR, or RTL text without numbers. | |
| * | |
| * Most of this is done by setting a bit for each directional property | |
| * in a flags variable and later checking for whether there are | |
| * any LTR characters or any RTL characters, or both, whether | |
| * there are any explicit embedding codes, etc. | |
| * | |
| * If the (Xn) steps are performed, then the flags are re-evaluated, | |
| * because they will then not contain the embedding codes any more | |
| * and will be adjusted for override codes, so that subsequently | |
| * more bypassing may be possible than what the initial flags suggested. | |
| * | |
| * If the text is not mixed-directional, then the | |
| * algorithm steps for the weak type resolution are not performed, | |
| * and all levels are set to the paragraph level. | |
| * | |
| * If there are no explicit embedding codes, then the (Xn) steps | |
| * are not performed. | |
| * | |
| * If embedding levels are supplied as a parameter, then all | |
| * explicit embedding codes are ignored, and the (Xn) steps | |
| * are not performed. | |
| * | |
| * White Space types could get the level of the run they belong to, | |
| * and are checked with a test of (flags&MASK_EMBEDDING) to | |
| * consider if the paragraph direction should be considered in | |
| * the flags variable. | |
| * | |
| * If there are no White Space types in the paragraph, then | |
| * (L1) is not necessary in adjustWSLevels(). | |
| */ | |
| /* 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] | |
| #define DIR_FROM_STRONG(strong) ((strong)==L ? L : R) | |
| #define NO_OVERRIDE(level) ((level)&~UBIDI_LEVEL_OVERRIDE) | |
| /* UBiDi object management -------------------------------------------------- */ | |
| U_CAPI UBiDi * U_EXPORT2 | |
| ubidi_open(void) | |
| { | |
| UErrorCode errorCode=U_ZERO_ERROR; | |
| return ubidi_openSized(0, 0, &errorCode); | |
| } | |
| U_CAPI UBiDi * U_EXPORT2 | |
| ubidi_openSized(int32_t maxLength, int32_t maxRunCount, UErrorCode *pErrorCode) { | |
| UBiDi *pBiDi; | |
| /* check the argument values */ | |
| if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) { | |
| return NULL; | |
| } else if(maxLength<0 || maxRunCount<0) { | |
| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; | |
| return NULL; /* invalid arguments */ | |
| } | |
| /* allocate memory for the object */ | |
| pBiDi=(UBiDi *)uprv_malloc(sizeof(UBiDi)); | |
| if(pBiDi==NULL) { | |
| *pErrorCode=U_MEMORY_ALLOCATION_ERROR; | |
| return NULL; | |
| } | |
| /* reset the object, all pointers NULL, all flags FALSE, all sizes 0 */ | |
| uprv_memset(pBiDi, 0, sizeof(UBiDi)); | |
| /* allocate memory for arrays as requested */ | |
| if(maxLength>0) { | |
| if( !getInitialDirPropsMemory(pBiDi, maxLength) || | |
| !getInitialLevelsMemory(pBiDi, maxLength) | |
| ) { | |
| *pErrorCode=U_MEMORY_ALLOCATION_ERROR; | |
| } | |
| } else { | |
| pBiDi->mayAllocateText=TRUE; | |
| } | |
| if(maxRunCount>0) { | |
| if(maxRunCount==1) { | |
| /* use simpleRuns[] */ | |
| pBiDi->runsSize=sizeof(Run); | |
| } else if(!getInitialRunsMemory(pBiDi, maxRunCount)) { | |
| *pErrorCode=U_MEMORY_ALLOCATION_ERROR; | |
| } | |
| } else { | |
| pBiDi->mayAllocateRuns=TRUE; | |
| } | |
| if(U_SUCCESS(*pErrorCode)) { | |
| return pBiDi; | |
| } else { | |
| ubidi_close(pBiDi); | |
| return NULL; | |
| } | |
| } | |
| /* | |
| * We are allowed to allocate memory if memory==NULL or | |
| * mayAllocate==TRUE for each array that we need. | |
| * We also try to grow memory as needed if we | |
| * allocate it. | |
| * | |
| * Assume sizeNeeded>0. | |
| * If *pMemory!=NULL, then assume *pSize>0. | |
| * | |
| * ### this realloc() may unnecessarily copy the old data, | |
| * which we know we don't need any more; | |
| * is this the best way to do this?? | |
| */ | |
| U_CFUNC UBool | |
| ubidi_getMemory(BidiMemoryForAllocation *bidiMem, int32_t *pSize, UBool mayAllocate, int32_t sizeNeeded) { | |
| void **pMemory = (void **)bidiMem; | |
| /* check for existing memory */ | |
| if(*pMemory==NULL) { | |
| /* we need to allocate memory */ | |
| if(mayAllocate && (*pMemory=uprv_malloc(sizeNeeded))!=NULL) { | |
| *pSize=sizeNeeded; | |
| return TRUE; | |
| } else { | |
| return FALSE; | |
| } | |
| } else { | |
| if(sizeNeeded<=*pSize) { | |
| /* there is already enough memory */ | |
| return TRUE; | |
| } | |
| else if(!mayAllocate) { | |
| /* not enough memory, and we must not allocate */ | |
| return FALSE; | |
| } else { | |
| /* we try to grow */ | |
| void *memory; | |
| /* in most cases, we do not need the copy-old-data part of | |
| * realloc, but it is needed when adding runs using getRunsMemory() | |
| * in setParaRunsOnly() | |
| */ | |
| if((memory=uprv_realloc(*pMemory, sizeNeeded))!=NULL) { | |
| *pMemory=memory; | |
| *pSize=sizeNeeded; | |
| return TRUE; | |
| } else { | |
| /* we failed to grow */ | |
| return FALSE; | |
| } | |
| } | |
| } | |
| } | |
| U_CAPI void U_EXPORT2 | |
| ubidi_close(UBiDi *pBiDi) { | |
| if(pBiDi!=NULL) { | |
| pBiDi->pParaBiDi=NULL; /* in case one tries to reuse this block */ | |
| if(pBiDi->dirPropsMemory!=NULL) { | |
| uprv_free(pBiDi->dirPropsMemory); | |
| } | |
| if(pBiDi->levelsMemory!=NULL) { | |
| uprv_free(pBiDi->levelsMemory); | |
| } | |
| if(pBiDi->openingsMemory!=NULL) { | |
| uprv_free(pBiDi->openingsMemory); | |
| } | |
| if(pBiDi->parasMemory!=NULL) { | |
| uprv_free(pBiDi->parasMemory); | |
| } | |
| if(pBiDi->runsMemory!=NULL) { | |
| uprv_free(pBiDi->runsMemory); | |
| } | |
| if(pBiDi->isolatesMemory!=NULL) { | |
| uprv_free(pBiDi->isolatesMemory); | |
| } | |
| if(pBiDi->insertPoints.points!=NULL) { | |
| uprv_free(pBiDi->insertPoints.points); | |
| } | |
| uprv_free(pBiDi); | |
| } | |
| } | |
| /* set to approximate "inverse BiDi" ---------------------------------------- */ | |
| U_CAPI void U_EXPORT2 | |
| ubidi_setInverse(UBiDi *pBiDi, UBool isInverse) { | |
| if(pBiDi!=NULL) { | |
| pBiDi->isInverse=isInverse; | |
| pBiDi->reorderingMode = isInverse ? UBIDI_REORDER_INVERSE_NUMBERS_AS_L | |
| : UBIDI_REORDER_DEFAULT; | |
| } | |
| } | |
| U_CAPI UBool U_EXPORT2 | |
| ubidi_isInverse(UBiDi *pBiDi) { | |
| if(pBiDi!=NULL) { | |
| return pBiDi->isInverse; | |
| } else { | |
| return FALSE; | |
| } | |
| } | |
| /* FOOD FOR THOUGHT: currently the reordering modes are a mixture of | |
| * algorithm for direct BiDi, algorithm for inverse BiDi and the bizarre | |
| * concept of RUNS_ONLY which is a double operation. | |
| * It could be advantageous to divide this into 3 concepts: | |
| * a) Operation: direct / inverse / RUNS_ONLY | |
| * b) Direct algorithm: default / NUMBERS_SPECIAL / GROUP_NUMBERS_WITH_R | |
| * c) Inverse algorithm: default / INVERSE_LIKE_DIRECT / NUMBERS_SPECIAL | |
| * This would allow combinations not possible today like RUNS_ONLY with | |
| * NUMBERS_SPECIAL. | |
| * Also allow to set INSERT_MARKS for the direct step of RUNS_ONLY and | |
| * REMOVE_CONTROLS for the inverse step. | |
| * Not all combinations would be supported, and probably not all do make sense. | |
| * This would need to document which ones are supported and what are the | |
| * fallbacks for unsupported combinations. | |
| */ | |
| U_CAPI void U_EXPORT2 | |
| ubidi_setReorderingMode(UBiDi *pBiDi, UBiDiReorderingMode reorderingMode) { | |
| if ((pBiDi!=NULL) && (reorderingMode >= UBIDI_REORDER_DEFAULT) | |
| && (reorderingMode < UBIDI_REORDER_COUNT)) { | |
| pBiDi->reorderingMode = reorderingMode; | |
| pBiDi->isInverse = (UBool)(reorderingMode == UBIDI_REORDER_INVERSE_NUMBERS_AS_L); | |
| } | |
| } | |
| U_CAPI UBiDiReorderingMode U_EXPORT2 | |
| ubidi_getReorderingMode(UBiDi *pBiDi) { | |
| if (pBiDi!=NULL) { | |
| return pBiDi->reorderingMode; | |
| } else { | |
| return UBIDI_REORDER_DEFAULT; | |
| } | |
| } | |
| U_CAPI void U_EXPORT2 | |
| ubidi_setReorderingOptions(UBiDi *pBiDi, uint32_t reorderingOptions) { | |
| if (reorderingOptions & UBIDI_OPTION_REMOVE_CONTROLS) { | |
| reorderingOptions&=~UBIDI_OPTION_INSERT_MARKS; | |
| } | |
| if (pBiDi!=NULL) { | |
| pBiDi->reorderingOptions=reorderingOptions; | |
| } | |
| } | |
| U_CAPI uint32_t U_EXPORT2 | |
| ubidi_getReorderingOptions(UBiDi *pBiDi) { | |
| if (pBiDi!=NULL) { | |
| return pBiDi->reorderingOptions; | |
| } else { | |
| return 0; | |
| } | |
| } | |
| U_CAPI UBiDiDirection U_EXPORT2 | |
| ubidi_getBaseDirection(const UChar *text, | |
| int32_t length){ | |
| int32_t i; | |
| UChar32 uchar; | |
| UCharDirection dir; | |
| if( text==NULL || length<-1 ){ | |
| return UBIDI_NEUTRAL; | |
| } | |
| if(length==-1) { | |
| length=u_strlen(text); | |
| } | |
| for( i = 0 ; i < length; ) { | |
| /* i is incremented by U16_NEXT */ | |
| U16_NEXT(text, i, length, uchar); | |
| dir = u_charDirection(uchar); | |
| if( dir == U_LEFT_TO_RIGHT ) | |
| return UBIDI_LTR; | |
| if( dir == U_RIGHT_TO_LEFT || dir ==U_RIGHT_TO_LEFT_ARABIC ) | |
| return UBIDI_RTL; | |
| } | |
| return UBIDI_NEUTRAL; | |
| } | |
| /* perform (P2)..(P3) ------------------------------------------------------- */ | |
| /** | |
| * Returns the directionality of the first strong character | |
| * after the last B in prologue, if any. | |
| * Requires prologue!=null. | |
| */ | |
| static DirProp | |
| firstL_R_AL(UBiDi *pBiDi) { | |
| const UChar *text=pBiDi->prologue; | |
| int32_t length=pBiDi->proLength; | |
| int32_t i; | |
| UChar32 uchar; | |
| DirProp dirProp, result=ON; | |
| for(i=0; i<length; ) { | |
| /* i is incremented by U16_NEXT */ | |
| U16_NEXT(text, i, length, uchar); | |
| dirProp=(DirProp)ubidi_getCustomizedClass(pBiDi, uchar); | |
| if(result==ON) { | |
| if(dirProp==L || dirProp==R || dirProp==AL) { | |
| result=dirProp; | |
| } | |
| } else { | |
| if(dirProp==B) { | |
| result=ON; | |
| } | |
| } | |
| } | |
| return result; | |
| } | |
| /* | |
| * Check that there are enough entries in the array pointed to by pBiDi->paras | |
| */ | |
| static UBool | |
| checkParaCount(UBiDi *pBiDi) { | |
| int32_t count=pBiDi->paraCount; | |
| if(pBiDi->paras==pBiDi->simpleParas) { | |
| if(count<=SIMPLE_PARAS_COUNT) | |
| return TRUE; | |
| if(!getInitialParasMemory(pBiDi, SIMPLE_PARAS_COUNT * 2)) | |
| return FALSE; | |
| pBiDi->paras=pBiDi->parasMemory; | |
| uprv_memcpy(pBiDi->parasMemory, pBiDi->simpleParas, SIMPLE_PARAS_COUNT * sizeof(Para)); | |
| return TRUE; | |
| } | |
| if(!getInitialParasMemory(pBiDi, count * 2)) | |
| return FALSE; | |
| pBiDi->paras=pBiDi->parasMemory; | |
| return TRUE; | |
| } | |
| /* | |
| * Get the directional properties for the text, calculate the flags bit-set, and | |
| * determine the paragraph level if necessary (in pBiDi->paras[i].level). | |
| * FSI initiators are also resolved and their dirProp replaced with LRI or RLI. | |
| * When encountering an FSI, it is initially replaced with an LRI, which is the | |
| * default. Only if a strong R or AL is found within its scope will the LRI be | |
| * replaced by an RLI. | |
| */ | |
| static UBool | |
| getDirProps(UBiDi *pBiDi) { | |
| const UChar *text=pBiDi->text; | |
| DirProp *dirProps=pBiDi->dirPropsMemory; /* pBiDi->dirProps is const */ | |
| int32_t i=0, originalLength=pBiDi->originalLength; | |
| Flags flags=0; /* collect all directionalities in the text */ | |
| UChar32 uchar; | |
| DirProp dirProp=0, defaultParaLevel=0; /* initialize to avoid compiler warnings */ | |
| UBool isDefaultLevel=IS_DEFAULT_LEVEL(pBiDi->paraLevel); | |
| /* for inverse BiDi, the default para level is set to RTL if there is a | |
| strong R or AL character at either end of the text */ | |
| UBool isDefaultLevelInverse=isDefaultLevel && (UBool) | |
| (pBiDi->reorderingMode==UBIDI_REORDER_INVERSE_LIKE_DIRECT || | |
| pBiDi->reorderingMode==UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL); | |
| int32_t lastArabicPos=-1; | |
| int32_t controlCount=0; | |
| UBool removeBiDiControls = (UBool)(pBiDi->reorderingOptions & | |
| UBIDI_OPTION_REMOVE_CONTROLS); | |
| enum State { | |
| NOT_SEEKING_STRONG, /* 0: not contextual paraLevel, not after FSI */ | |
| SEEKING_STRONG_FOR_PARA, /* 1: looking for first strong char in para */ | |
| SEEKING_STRONG_FOR_FSI, /* 2: looking for first strong after FSI */ | |
| LOOKING_FOR_PDI /* 3: found strong after FSI, looking for PDI */ | |
| }; | |
| State state; | |
| DirProp lastStrong=ON; /* for default level & inverse BiDi */ | |
| /* The following stacks are used to manage isolate sequences. Those | |
| sequences may be nested, but obviously never more deeply than the | |
| maximum explicit embedding level. | |
| lastStack is the index of the last used entry in the stack. A value of -1 | |
| means that there is no open isolate sequence. | |
| lastStack is reset to -1 on paragraph boundaries. */ | |
| /* The following stack contains the position of the initiator of | |
| each open isolate sequence */ | |
| int32_t isolateStartStack[UBIDI_MAX_EXPLICIT_LEVEL+1]; | |
| /* The following stack contains the last known state before | |
| encountering the initiator of an isolate sequence */ | |
| State previousStateStack[UBIDI_MAX_EXPLICIT_LEVEL+1]; | |
| int32_t stackLast=-1; | |
| if(pBiDi->reorderingOptions & UBIDI_OPTION_STREAMING) | |
| pBiDi->length=0; | |
| defaultParaLevel=pBiDi->paraLevel&1; | |
| if(isDefaultLevel) { | |
| pBiDi->paras[0].level=defaultParaLevel; | |
| lastStrong=defaultParaLevel; | |
| if(pBiDi->proLength>0 && /* there is a prologue */ | |
| (dirProp=firstL_R_AL(pBiDi))!=ON) { /* with a strong character */ | |
| if(dirProp==L) | |
| pBiDi->paras[0].level=0; /* set the default para level */ | |
| else | |
| pBiDi->paras[0].level=1; /* set the default para level */ | |
| state=NOT_SEEKING_STRONG; | |
| } else { | |
| state=SEEKING_STRONG_FOR_PARA; | |
| } | |
| } else { | |
| pBiDi->paras[0].level=pBiDi->paraLevel; | |
| state=NOT_SEEKING_STRONG; | |
| } | |
| /* count paragraphs and determine the paragraph level (P2..P3) */ | |
| /* | |
| * see comment in ubidi.h: | |
| * the UBIDI_DEFAULT_XXX values are designed so that | |
| * their bit 0 alone yields the intended default | |
| */ | |
| for( /* i=0 above */ ; i<originalLength; ) { | |
| /* i is incremented by U16_NEXT */ | |
| U16_NEXT(text, i, originalLength, uchar); | |
| flags|=DIRPROP_FLAG(dirProp=(DirProp)ubidi_getCustomizedClass(pBiDi, uchar)); | |
| dirProps[i-1]=dirProp; | |
| if(uchar>0xffff) { /* set the lead surrogate's property to BN */ | |
| flags|=DIRPROP_FLAG(BN); | |
| dirProps[i-2]=BN; | |
| } | |
| if(removeBiDiControls && IS_BIDI_CONTROL_CHAR(uchar)) | |
| controlCount++; | |
| if(dirProp==L) { | |
| if(state==SEEKING_STRONG_FOR_PARA) { | |
| pBiDi->paras[pBiDi->paraCount-1].level=0; | |
| state=NOT_SEEKING_STRONG; | |
| } | |
| else if(state==SEEKING_STRONG_FOR_FSI) { | |
| if(stackLast<=UBIDI_MAX_EXPLICIT_LEVEL) { | |
| /* no need for next statement, already set by default */ | |
| /* dirProps[isolateStartStack[stackLast]]=LRI; */ | |
| flags|=DIRPROP_FLAG(LRI); | |
| } | |
| state=LOOKING_FOR_PDI; | |
| } | |
| lastStrong=L; | |
| continue; | |
| } | |
| if(dirProp==R || dirProp==AL) { | |
| if(state==SEEKING_STRONG_FOR_PARA) { | |
| pBiDi->paras[pBiDi->paraCount-1].level=1; | |
| state=NOT_SEEKING_STRONG; | |
| } | |
| else if(state==SEEKING_STRONG_FOR_FSI) { | |
| if(stackLast<=UBIDI_MAX_EXPLICIT_LEVEL) { | |
| dirProps[isolateStartStack[stackLast]]=RLI; | |
| flags|=DIRPROP_FLAG(RLI); | |
| } | |
| state=LOOKING_FOR_PDI; | |
| } | |
| lastStrong=R; | |
| if(dirProp==AL) | |
| lastArabicPos=i-1; | |
| continue; | |
| } | |
| if(dirProp>=FSI && dirProp<=RLI) { /* FSI, LRI or RLI */ | |
| stackLast++; | |
| if(stackLast<=UBIDI_MAX_EXPLICIT_LEVEL) { | |
| isolateStartStack[stackLast]=i-1; | |
| previousStateStack[stackLast]=state; | |
| } | |
| if(dirProp==FSI) { | |
| dirProps[i-1]=LRI; /* default if no strong char */ | |
| state=SEEKING_STRONG_FOR_FSI; | |
| } | |
| else | |
| state=LOOKING_FOR_PDI; | |
| continue; | |
| } | |
| if(dirProp==PDI) { | |
| if(state==SEEKING_STRONG_FOR_FSI) { | |
| if(stackLast<=UBIDI_MAX_EXPLICIT_LEVEL) { | |
| /* no need for next statement, already set by default */ | |
| /* dirProps[isolateStartStack[stackLast]]=LRI; */ | |
| flags|=DIRPROP_FLAG(LRI); | |
| } | |
| } | |
| if(stackLast>=0) { | |
| if(stackLast<=UBIDI_MAX_EXPLICIT_LEVEL) | |
| state=previousStateStack[stackLast]; | |
| stackLast--; | |
| } | |
| continue; | |
| } | |
| if(dirProp==B) { | |
| if(i<originalLength && uchar==CR && text[i]==LF) /* do nothing on the CR */ | |
| continue; | |
| pBiDi->paras[pBiDi->paraCount-1].limit=i; | |
| if(isDefaultLevelInverse && lastStrong==R) | |
| pBiDi->paras[pBiDi->paraCount-1].level=1; | |
| if(pBiDi->reorderingOptions & UBIDI_OPTION_STREAMING) { | |
| /* When streaming, we only process whole paragraphs | |
| thus some updates are only done on paragraph boundaries */ | |
| pBiDi->length=i; /* i is index to next character */ | |
| pBiDi->controlCount=controlCount; | |
| } | |
| if(i<originalLength) { /* B not last char in text */ | |
| pBiDi->paraCount++; | |
| if(checkParaCount(pBiDi)==FALSE) /* not enough memory for a new para entry */ | |
| return FALSE; | |
| if(isDefaultLevel) { | |
| pBiDi->paras[pBiDi->paraCount-1].level=defaultParaLevel; | |
| state=SEEKING_STRONG_FOR_PARA; | |
| lastStrong=defaultParaLevel; | |
| } else { | |
| pBiDi->paras[pBiDi->paraCount-1].level=pBiDi->paraLevel; | |
| state=NOT_SEEKING_STRONG; | |
| } | |
| stackLast=-1; | |
| } | |
| continue; | |
| } | |
| } | |
| /* Ignore still open isolate sequences with overflow */ | |
| if(stackLast>UBIDI_MAX_EXPLICIT_LEVEL) { | |
| stackLast=UBIDI_MAX_EXPLICIT_LEVEL; | |
| state=SEEKING_STRONG_FOR_FSI; /* to be on the safe side */ | |
| } | |
| /* Resolve direction of still unresolved open FSI sequences */ | |
| while(stackLast>=0) { | |
| if(state==SEEKING_STRONG_FOR_FSI) { | |
| /* no need for next statement, already set by default */ | |
| /* dirProps[isolateStartStack[stackLast]]=LRI; */ | |
| flags|=DIRPROP_FLAG(LRI); | |
| break; | |
| } | |
| state=previousStateStack[stackLast]; | |
| stackLast--; | |
| } | |
| /* When streaming, ignore text after the last paragraph separator */ | |
| if(pBiDi->reorderingOptions & UBIDI_OPTION_STREAMING) { | |
| if(pBiDi->length<originalLength) | |
| pBiDi->paraCount--; | |
| } else { | |
| pBiDi->paras[pBiDi->paraCount-1].limit=originalLength; | |
| pBiDi->controlCount=controlCount; | |
| } | |
| /* For inverse bidi, default para direction is RTL if there is | |
| a strong R or AL at either end of the paragraph */ | |
| if(isDefaultLevelInverse && lastStrong==R) { | |
| pBiDi->paras[pBiDi->paraCount-1].level=1; | |
| } | |
| if(isDefaultLevel) { | |
| pBiDi->paraLevel=static_cast<UBiDiLevel>(pBiDi->paras[0].level); | |
| } | |
| /* The following is needed to resolve the text direction for default level | |
| paragraphs containing no strong character */ | |
| for(i=0; i<pBiDi->paraCount; i++) | |
| flags|=DIRPROP_FLAG_LR(pBiDi->paras[i].level); | |
| if(pBiDi->orderParagraphsLTR && (flags&DIRPROP_FLAG(B))) { | |
| flags|=DIRPROP_FLAG(L); | |
| } | |
| pBiDi->flags=flags; | |
| pBiDi->lastArabicPos=lastArabicPos; | |
| return TRUE; | |
| } | |
| /* determine the paragraph level at position index */ | |
| U_CFUNC UBiDiLevel | |
| ubidi_getParaLevelAtIndex(const UBiDi *pBiDi, int32_t pindex) { | |
| int32_t i; | |
| for(i=0; i<pBiDi->paraCount; i++) | |
| if(pindex<pBiDi->paras[i].limit) | |
| break; | |
| if(i>=pBiDi->paraCount) | |
| i=pBiDi->paraCount-1; | |
| return (UBiDiLevel)(pBiDi->paras[i].level); | |
| } | |
| /* Functions for handling paired brackets ----------------------------------- */ | |
| /* In the isoRuns array, the first entry is used for text outside of any | |
| isolate sequence. Higher entries are used for each more deeply nested | |
| isolate sequence. isoRunLast is the index of the last used entry. The | |
| openings array is used to note the data of opening brackets not yet | |
| matched by a closing bracket, or matched but still susceptible to change | |
| level. | |
| Each isoRun entry contains the index of the first and | |
| one-after-last openings entries for pending opening brackets it | |
| contains. The next openings entry to use is the one-after-last of the | |
| most deeply nested isoRun entry. | |
| isoRun entries also contain their current embedding level and the last | |
| encountered strong character, since these will be needed to resolve | |
| the level of paired brackets. */ | |
| static void | |
| bracketInit(UBiDi *pBiDi, BracketData *bd) { | |
| bd->pBiDi=pBiDi; | |
| bd->isoRunLast=0; | |
| bd->isoRuns[0].start=0; | |
| bd->isoRuns[0].limit=0; | |
| bd->isoRuns[0].level=GET_PARALEVEL(pBiDi, 0); | |
| UBiDiLevel t = GET_PARALEVEL(pBiDi, 0) & 1; | |
| bd->isoRuns[0].lastStrong = bd->isoRuns[0].lastBase = t; | |
| bd->isoRuns[0].contextDir = (UBiDiDirection)t; | |
| bd->isoRuns[0].contextPos=0; | |
| if(pBiDi->openingsMemory) { | |
| bd->openings=pBiDi->openingsMemory; | |
| bd->openingsCount=pBiDi->openingsSize / sizeof(Opening); | |
| } else { | |
| bd->openings=bd->simpleOpenings; | |
| bd->openingsCount=SIMPLE_OPENINGS_COUNT; | |
| } | |
| bd->isNumbersSpecial=bd->pBiDi->reorderingMode==UBIDI_REORDER_NUMBERS_SPECIAL || | |
| bd->pBiDi->reorderingMode==UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL; | |
| } | |
| /* paragraph boundary */ | |
| static void | |
| bracketProcessB(BracketData *bd, UBiDiLevel level) { | |
| bd->isoRunLast=0; | |
| bd->isoRuns[0].limit=0; | |
| bd->isoRuns[0].level=level; | |
| bd->isoRuns[0].lastStrong=bd->isoRuns[0].lastBase=level&1; | |
| bd->isoRuns[0].contextDir=(UBiDiDirection)(level&1); | |
| bd->isoRuns[0].contextPos=0; | |
| } | |
| /* LRE, LRO, RLE, RLO, PDF */ | |
| static void | |
| bracketProcessBoundary(BracketData *bd, int32_t lastCcPos, | |
| UBiDiLevel contextLevel, UBiDiLevel embeddingLevel) { | |
| IsoRun *pLastIsoRun=&bd->isoRuns[bd->isoRunLast]; | |
| DirProp *dirProps=bd->pBiDi->dirProps; | |
| if(DIRPROP_FLAG(dirProps[lastCcPos])&MASK_ISO) /* after an isolate */ | |
| return; | |
| if(NO_OVERRIDE(embeddingLevel)>NO_OVERRIDE(contextLevel)) /* not a PDF */ | |
| contextLevel=embeddingLevel; | |
| pLastIsoRun->limit=pLastIsoRun->start; | |
| pLastIsoRun->level=embeddingLevel; | |
| pLastIsoRun->lastStrong=pLastIsoRun->lastBase=contextLevel&1; | |
| pLastIsoRun->contextDir=(UBiDiDirection)(contextLevel&1); | |
| pLastIsoRun->contextPos=(UBiDiDirection)lastCcPos; | |
| } | |
| /* LRI or RLI */ | |
| static void | |
| bracketProcessLRI_RLI(BracketData *bd, UBiDiLevel level) { | |
| IsoRun *pLastIsoRun=&bd->isoRuns[bd->isoRunLast]; | |
| int16_t lastLimit; | |
| pLastIsoRun->lastBase=ON; | |
| lastLimit=pLastIsoRun->limit; | |
| bd->isoRunLast++; | |
| pLastIsoRun++; | |
| pLastIsoRun->start=pLastIsoRun->limit=lastLimit; | |
| pLastIsoRun->level=level; | |
| pLastIsoRun->lastStrong=pLastIsoRun->lastBase=level&1; | |
| pLastIsoRun->contextDir=(UBiDiDirection)(level&1); | |
| pLastIsoRun->contextPos=0; | |
| } | |
| /* PDI */ | |
| static void | |
| bracketProcessPDI(BracketData *bd) { | |
| IsoRun *pLastIsoRun; | |
| bd->isoRunLast--; | |
| pLastIsoRun=&bd->isoRuns[bd->isoRunLast]; | |
| pLastIsoRun->lastBase=ON; | |
| } | |
| /* newly found opening bracket: create an openings entry */ | |
| static UBool /* return TRUE if success */ | |
| bracketAddOpening(BracketData *bd, UChar match, int32_t position) { | |
| IsoRun *pLastIsoRun=&bd->isoRuns[bd->isoRunLast]; | |
| Opening *pOpening; | |
| if(pLastIsoRun->limit>=bd->openingsCount) { /* no available new entry */ | |
| UBiDi *pBiDi=bd->pBiDi; | |
| if(!getInitialOpeningsMemory(pBiDi, pLastIsoRun->limit * 2)) | |
| return FALSE; | |
| if(bd->openings==bd->simpleOpenings) | |
| uprv_memcpy(pBiDi->openingsMemory, bd->simpleOpenings, | |
| SIMPLE_OPENINGS_COUNT * sizeof(Opening)); | |
| bd->openings=pBiDi->openingsMemory; /* may have changed */ | |
| bd->openingsCount=pBiDi->openingsSize / sizeof(Opening); | |
| } | |
| pOpening=&bd->openings[pLastIsoRun->limit]; | |
| pOpening->position=position; | |
| pOpening->match=match; | |
| pOpening->contextDir=pLastIsoRun->contextDir; | |
| pOpening->contextPos=pLastIsoRun->contextPos; | |
| pOpening->flags=0; | |
| pLastIsoRun->limit++; | |
| return TRUE; | |
| } | |
| /* change N0c1 to N0c2 when a preceding bracket is assigned the embedding level */ | |
| static void | |
| fixN0c(BracketData *bd, int32_t openingIndex, int32_t newPropPosition, DirProp newProp) { | |
| /* This function calls itself recursively */ | |
| IsoRun *pLastIsoRun=&bd->isoRuns[bd->isoRunLast]; | |
| Opening *qOpening; | |
| DirProp *dirProps=bd->pBiDi->dirProps; | |
| int32_t k, openingPosition, closingPosition; | |
| for(k=openingIndex+1, qOpening=&bd->openings[k]; k<pLastIsoRun->limit; k++, qOpening++) { | |
| if(qOpening->match>=0) /* not an N0c match */ | |
| continue; | |
| if(newPropPosition<qOpening->contextPos) | |
| break; | |
| if(newPropPosition>=qOpening->position) | |
| continue; | |
| if(newProp==qOpening->contextDir) | |
| break; | |
| openingPosition=qOpening->position; | |
| dirProps[openingPosition]=newProp; | |
| closingPosition=-(qOpening->match); | |
| dirProps[closingPosition]=newProp; | |
| qOpening->match=0; /* prevent further changes */ | |
| fixN0c(bd, k, openingPosition, newProp); | |
| fixN0c(bd, k, closingPosition, newProp); | |
| } | |
| } | |
| /* process closing bracket */ | |
| static DirProp /* return L or R if N0b or N0c, ON if N0d */ | |
| bracketProcessClosing(BracketData *bd, int32_t openIdx, int32_t position) { | |
| IsoRun *pLastIsoRun=&bd->isoRuns[bd->isoRunLast]; | |
| Opening *pOpening, *qOpening; | |
| UBiDiDirection direction; | |
| UBool stable; | |
| DirProp newProp; | |
| pOpening=&bd->openings[openIdx]; | |
| direction=(UBiDiDirection)(pLastIsoRun->level&1); | |
| stable=TRUE; /* assume stable until proved otherwise */ | |
| /* The stable flag is set when brackets are paired and their | |
| level is resolved and cannot be changed by what will be | |
| found later in the source string. | |
| An unstable match can occur only when applying N0c, where | |
| the resolved level depends on the preceding context, and | |
| this context may be affected by text occurring later. | |
| Example: RTL paragraph containing: abc[(latin) HEBREW] | |
| When the closing parenthesis is encountered, it appears | |
| that N0c1 must be applied since 'abc' sets an opposite | |
| direction context and both parentheses receive level 2. | |
| However, when the closing square bracket is processed, | |
| N0b applies because of 'HEBREW' being included within the | |
| brackets, thus the square brackets are treated like R and | |
| receive level 1. However, this changes the preceding | |
| context of the opening parenthesis, and it now appears | |
| that N0c2 must be applied to the parentheses rather than | |
| N0c1. */ | |
| if((direction==0 && pOpening->flags&FOUND_L) || | |
| (direction==1 && pOpening->flags&FOUND_R)) { /* N0b */ | |
| newProp=static_cast<DirProp>(direction); | |
| } | |
| else if(pOpening->flags&(FOUND_L|FOUND_R)) { /* N0c */ | |
| /* it is stable if there is no containing pair or in | |
| conditions too complicated and not worth checking */ | |
| stable=(openIdx==pLastIsoRun->start); | |
| if(direction!=pOpening->contextDir) | |
| newProp= static_cast<DirProp>(pOpening->contextDir); /* N0c1 */ | |
| else | |
| newProp= static_cast<DirProp>(direction); /* N0c2 */ | |
| } else { | |
| /* forget this and any brackets nested within this pair */ | |
| pLastIsoRun->limit= static_cast<uint16_t>(openIdx); | |
| return ON; /* N0d */ | |
| } | |
| bd->pBiDi->dirProps[pOpening->position]=newProp; | |
| bd->pBiDi->dirProps[position]=newProp; | |
| /* Update nested N0c pairs that may be affected */ | |
| fixN0c(bd, openIdx, pOpening->position, newProp); | |
| if(stable) { | |
| pLastIsoRun->limit= static_cast<uint16_t>(openIdx); /* forget any brackets nested within this pair */ | |
| /* remove lower located synonyms if any */ | |
| while(pLastIsoRun->limit>pLastIsoRun->start && | |
| bd->openings[pLastIsoRun->limit-1].position==pOpening->position) | |
| pLastIsoRun->limit--; | |
| } else { | |
| int32_t k; | |
| pOpening->match=-position; | |
| /* neutralize lower located synonyms if any */ | |
| k=openIdx-1; | |
| while(k>=pLastIsoRun->start && | |
| bd->openings[k].position==pOpening->position) | |
| bd->openings[k--].match=0; | |
| /* neutralize any unmatched opening between the current pair; | |
| this will also neutralize higher located synonyms if any */ | |
| for(k=openIdx+1; k<pLastIsoRun->limit; k++) { | |
| qOpening=&bd->openings[k]; | |
| if(qOpening->position>=position) | |
| break; | |
| if(qOpening->match>0) | |
| qOpening->match=0; | |
| } | |
| } | |
| return newProp; | |
| } | |
| /* handle strong characters, digits and candidates for closing brackets */ | |
| static UBool /* return TRUE if success */ | |
| bracketProcessChar(BracketData *bd, int32_t position) { | |
| IsoRun *pLastIsoRun=&bd->isoRuns[bd->isoRunLast]; | |
| DirProp *dirProps, dirProp, newProp; | |
| UBiDiLevel level; | |
| dirProps=bd->pBiDi->dirProps; | |
| dirProp=dirProps[position]; | |
| if(dirProp==ON) { | |
| UChar c, match; | |
| int32_t idx; | |
| /* First see if it is a matching closing bracket. Hopefully, this is | |
| more efficient than checking if it is a closing bracket at all */ | |
| c=bd->pBiDi->text[position]; | |
| for(idx=pLastIsoRun->limit-1; idx>=pLastIsoRun->start; idx--) { | |
| if(bd->openings[idx].match!=c) | |
| continue; | |
| /* We have a match */ | |
| newProp=bracketProcessClosing(bd, idx, position); | |
| if(newProp==ON) { /* N0d */ | |
| c=0; /* prevent handling as an opening */ | |
| break; | |
| } | |
| pLastIsoRun->lastBase=ON; | |
| pLastIsoRun->contextDir=(UBiDiDirection)newProp; | |
| pLastIsoRun->contextPos=position; | |
| level=bd->pBiDi->levels[position]; | |
| if(level&UBIDI_LEVEL_OVERRIDE) { /* X4, X5 */ | |
| uint16_t flag; | |
| int32_t i; | |
| newProp=level&1; | |
| pLastIsoRun->lastStrong=newProp; | |
| flag=DIRPROP_FLAG(newProp); | |
| for(i=pLastIsoRun->start; i<idx; i++) | |
| bd->openings[i].flags|=flag; | |
| /* matching brackets are not overridden by LRO/RLO */ | |
| bd->pBiDi->levels[position]&=~UBIDI_LEVEL_OVERRIDE; | |
| } | |
| /* matching brackets are not overridden by LRO/RLO */ | |
| bd->pBiDi->levels[bd->openings[idx].position]&=~UBIDI_LEVEL_OVERRIDE; | |
| return TRUE; | |
| } | |
| /* We get here only if the ON character is not a matching closing | |
| bracket or it is a case of N0d */ | |
| /* Now see if it is an opening bracket */ | |
| if(c) | |
| match= static_cast<UChar>(u_getBidiPairedBracket(c)); /* get the matching char */ | |
| else | |
| match=0; | |
| if(match!=c && /* has a matching char */ | |
| ubidi_getPairedBracketType(c)==U_BPT_OPEN) { /* opening bracket */ | |
| /* special case: process synonyms | |
| create an opening entry for each synonym */ | |
| if(match==0x232A) { /* RIGHT-POINTING ANGLE BRACKET */ | |
| if(!bracketAddOpening(bd, 0x3009, position)) | |
| return FALSE; | |
| } | |
| else if(match==0x3009) { /* RIGHT ANGLE BRACKET */ | |
| if(!bracketAddOpening(bd, 0x232A, position)) | |
| return FALSE; | |
| } | |
| if(!bracketAddOpening(bd, match, position)) | |
| return FALSE; | |
| } | |
| } | |
| level=bd->pBiDi->levels[position]; | |
| if(level&UBIDI_LEVEL_OVERRIDE) { /* X4, X5 */ | |
| newProp=level&1; | |
| if(dirProp!=S && dirProp!=WS && dirProp!=ON) | |
| dirProps[position]=newProp; | |
| pLastIsoRun->lastBase=newProp; | |
| pLastIsoRun->lastStrong=newProp; | |
| pLastIsoRun->contextDir=(UBiDiDirection)newProp; | |
| pLastIsoRun->contextPos=position; | |
| } | |
| else if(dirProp<=R || dirProp==AL) { | |
| newProp= static_cast<DirProp>(DIR_FROM_STRONG(dirProp)); | |
| pLastIsoRun->lastBase=dirProp; | |
| pLastIsoRun->lastStrong=dirProp; | |
| pLastIsoRun->contextDir=(UBiDiDirection)newProp; | |
| pLastIsoRun->contextPos=position; | |
| } | |
| else if(dirProp==EN) { | |
| pLastIsoRun->lastBase=EN; | |
| if(pLastIsoRun->lastStrong==L) { | |
| newProp=L; /* W7 */ | |
| if(!bd->isNumbersSpecial) | |
| dirProps[position]=ENL; | |
| pLastIsoRun->contextDir=(UBiDiDirection)L; | |
| pLastIsoRun->contextPos=position; | |
| } | |
| else { | |
| newProp=R; /* N0 */ | |
| if(pLastIsoRun->lastStrong==AL) | |
| dirProps[position]=AN; /* W2 */ | |
| else | |
| dirProps[position]=ENR; | |
| pLastIsoRun->contextDir=(UBiDiDirection)R; | |
| pLastIsoRun->contextPos=position; | |
| } | |
| } | |
| else if(dirProp==AN) { | |
| newProp=R; /* N0 */ | |
| pLastIsoRun->lastBase=AN; | |
| pLastIsoRun->contextDir=(UBiDiDirection)R; | |
| pLastIsoRun->contextPos=position; | |
| } | |
| else if(dirProp==NSM) { | |
| /* if the last real char was ON, change NSM to ON so that it | |
| will stay ON even if the last real char is a bracket which | |
| may be changed to L or R */ | |
| newProp=pLastIsoRun->lastBase; | |
| if(newProp==ON) | |
| dirProps[position]=newProp; | |
| } | |
| else { | |
| newProp=dirProp; | |
| pLastIsoRun->lastBase=dirProp; | |
| } | |
| if(newProp<=R || newProp==AL) { | |
| int32_t i; | |
| uint16_t flag=DIRPROP_FLAG(DIR_FROM_STRONG(newProp)); | |
| for(i=pLastIsoRun->start; i<pLastIsoRun->limit; i++) | |
| if(position>bd->openings[i].position) | |
| bd->openings[i].flags|=flag; | |
| } | |
| return TRUE; | |
| } | |
| /* perform (X1)..(X9) ------------------------------------------------------- */ | |
| /* determine if the text is mixed-directional or single-directional */ | |
| static UBiDiDirection | |
| directionFromFlags(UBiDi *pBiDi) { | |
| Flags flags=pBiDi->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; | |
| } | |
| } | |
| /* | |
| * Resolve the explicit levels as specified by explicit embedding codes. | |
| * Recalculate the flags to have them reflect the real properties | |
| * after taking the explicit embeddings into account. | |
| * | |
| * The BiDi algorithm is designed to result in the same behavior whether embedding | |
| * levels are externally specified (from "styled text", supposedly the preferred | |
| * method) or set by explicit embedding codes (LRx, RLx, PDF, FSI, PDI) in the plain text. | |
| * That is why (X9) instructs to remove all not-isolate explicit codes (and BN). | |
| * However, in a real implementation, the removal of these codes and their index | |
| * positions in the plain text is undesirable since it would result in | |
| * reallocated, reindexed text. | |
| * Instead, this implementation leaves the codes in there and just ignores them | |
| * in the subsequent processing. | |
| * In order to get the same reordering behavior, positions with a BN or a not-isolate | |
| * explicit embedding code just get the same level assigned as the last "real" | |
| * character. | |
| * | |
| * Some implementations, not this one, then overwrite some of these | |
| * directionality properties at "real" same-level-run boundaries by | |
| * L or R codes so that the resolution of weak types can be performed on the | |
| * entire paragraph at once instead of having to parse it once more and | |
| * perform that resolution on same-level-runs. | |
| * This limits the scope of the implicit rules in effectively | |
| * the same way as the run limits. | |
| * | |
| * Instead, this implementation does not modify these codes, except for | |
| * paired brackets whose properties (ON) may be replaced by L or R. | |
| * On one hand, the paragraph has to be scanned for same-level-runs, but | |
| * on the other hand, this saves another loop to reset these codes, | |
| * or saves making and modifying a copy of dirProps[]. | |
| * | |
| * | |
| * Note that (Pn) and (Xn) changed significantly from version 4 of the BiDi algorithm. | |
| * | |
| * | |
| * Handling the stack of explicit levels (Xn): | |
| * | |
| * With the BiDi stack of explicit levels, as pushed with each | |
| * LRE, RLE, LRO, RLO, LRI, RLI and FSI and popped with each PDF and PDI, | |
| * the explicit level must never exceed UBIDI_MAX_EXPLICIT_LEVEL. | |
| * | |
| * In order to have a correct push-pop semantics even in the case of overflows, | |
| * overflow counters and a valid isolate counter are used as described in UAX#9 | |
| * section 3.3.2 "Explicit Levels and Directions". | |
| * | |
| * This implementation assumes that UBIDI_MAX_EXPLICIT_LEVEL is odd. | |
| * | |
| * Returns normally the direction; -1 if there was a memory shortage | |
| * | |
| */ | |
| static UBiDiDirection | |
| resolveExplicitLevels(UBiDi *pBiDi, UErrorCode *pErrorCode) { | |
| DirProp *dirProps=pBiDi->dirProps; | |
| UBiDiLevel *levels=pBiDi->levels; | |
| const UChar *text=pBiDi->text; | |
| int32_t i=0, length=pBiDi->length; | |
| Flags flags=pBiDi->flags; /* collect all directionalities in the text */ | |
| DirProp dirProp; | |
| UBiDiLevel level=GET_PARALEVEL(pBiDi, 0); | |
| UBiDiDirection direction; | |
| pBiDi->isolateCount=0; | |
| if(U_FAILURE(*pErrorCode)) { return UBIDI_LTR; } | |
| /* determine if the text is mixed-directional or single-directional */ | |
| direction=directionFromFlags(pBiDi); | |
| /* we may not need to resolve any explicit levels */ | |
| if((direction!=UBIDI_MIXED)) { | |
| /* not mixed directionality: levels don't matter - trailingWSStart will be 0 */ | |
| return direction; | |
| } | |
| if(pBiDi->reorderingMode > UBIDI_REORDER_LAST_LOGICAL_TO_VISUAL) { | |
| /* inverse BiDi: mixed, but all characters are at the same embedding level */ | |
| /* set all levels to the paragraph level */ | |
| int32_t paraIndex, start, limit; | |
| for(paraIndex=0; paraIndex<pBiDi->paraCount; paraIndex++) { | |
| if(paraIndex==0) | |
| start=0; | |
| else | |
| start=pBiDi->paras[paraIndex-1].limit; | |
| limit=pBiDi->paras[paraIndex].limit; | |
| level= static_cast<UBiDiLevel>(pBiDi->paras[paraIndex].level); | |
| for(i=start; i<limit; i++) | |
| levels[i]=level; | |
| } | |
| return direction; /* no bracket matching for inverse BiDi */ | |
| } | |
| if(!(flags&(MASK_EXPLICIT|MASK_ISO))) { | |
| /* no embeddings, set all levels to the paragraph level */ | |
| /* we still have to perform bracket matching */ | |
| int32_t paraIndex, start, limit; | |
| BracketData bracketData; | |
| bracketInit(pBiDi, &bracketData); | |
| for(paraIndex=0; paraIndex<pBiDi->paraCount; paraIndex++) { | |
| if(paraIndex==0) | |
| start=0; | |
| else | |
| start=pBiDi->paras[paraIndex-1].limit; | |
| limit=pBiDi->paras[paraIndex].limit; | |
| level= static_cast<UBiDiLevel>(pBiDi->paras[paraIndex].level); | |
| for(i=start; i<limit; i++) { | |
| levels[i]=level; | |
| dirProp=dirProps[i]; | |
| if(dirProp==BN) | |
| continue; | |
| if(dirProp==B) { | |
| if((i+1)<length) { | |
| if(text[i]==CR && text[i+1]==LF) | |
| continue; /* skip CR when followed by LF */ | |
| bracketProcessB(&bracketData, level); | |
| } | |
| continue; | |
| } | |
| if(!bracketProcessChar(&bracketData, i)) { | |
| *pErrorCode=U_MEMORY_ALLOCATION_ERROR; | |
| return UBIDI_LTR; | |
| } | |
| } | |
| } | |
| return direction; | |
| } | |
| { | |
| /* 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; | |
| UBiDiLevel previousLevel=level; /* previous level for regular (not CC) characters */ | |
| int32_t lastCcPos=0; /* index of last effective LRx,RLx, PDx */ | |
| /* The following stack remembers the embedding level and the ISOLATE flag of level runs. | |
| stackLast points to its current entry. */ | |
| uint16_t stack[UBIDI_MAX_EXPLICIT_LEVEL+2]; /* we never push anything >=UBIDI_MAX_EXPLICIT_LEVEL | |
| but we need one more entry as base */ | |
| uint32_t stackLast=0; | |
| int32_t overflowIsolateCount=0; | |
| int32_t overflowEmbeddingCount=0; | |
| int32_t validIsolateCount=0; | |
| BracketData bracketData; | |
| bracketInit(pBiDi, &bracketData); | |
| stack[0]=level; /* initialize base entry to para level, no override, no isolate */ | |
| /* recalculate the flags */ | |
| flags=0; | |
| for(i=0; i<length; ++i) { | |
| dirProp=dirProps[i]; | |
| switch(dirProp) { | |
| case LRE: | |
| case RLE: | |
| case LRO: | |
| case RLO: | |
| /* (X2, X3, X4, X5) */ | |
| flags|=DIRPROP_FLAG(BN); | |
| levels[i]=previousLevel; | |
| if (dirProp==LRE || dirProp==LRO) | |
| /* least greater even level */ | |
| newLevel=(UBiDiLevel)((embeddingLevel+2)&~(UBIDI_LEVEL_OVERRIDE|1)); | |
| else | |
| /* least greater odd level */ | |
| newLevel=(UBiDiLevel)((NO_OVERRIDE(embeddingLevel)+1)|1); | |
| if(newLevel<=UBIDI_MAX_EXPLICIT_LEVEL && overflowIsolateCount==0 && | |
| overflowEmbeddingCount==0) { | |
| lastCcPos=i; | |
| embeddingLevel=newLevel; | |
| if(dirProp==LRO || dirProp==RLO) | |
| embeddingLevel|=UBIDI_LEVEL_OVERRIDE; | |
| stackLast++; | |
| stack[stackLast]=embeddingLevel; | |
| /* we don't need to set UBIDI_LEVEL_OVERRIDE off for LRE and RLE | |
| since this has already been done for newLevel which is | |
| the source for embeddingLevel. | |
| */ | |
| } else { | |
| if(overflowIsolateCount==0) | |
| overflowEmbeddingCount++; | |
| } | |
| break; | |
| case PDF: | |
| /* (X7) */ | |
| flags|=DIRPROP_FLAG(BN); | |
| levels[i]=previousLevel; | |
| /* handle all the overflow cases first */ | |
| if(overflowIsolateCount) { | |
| break; | |
| } | |
| if(overflowEmbeddingCount) { | |
| overflowEmbeddingCount--; | |
| break; | |
| } | |
| if(stackLast>0 && stack[stackLast]<ISOLATE) { /* not an isolate entry */ | |
| lastCcPos=i; | |
| stackLast--; | |
| embeddingLevel=(UBiDiLevel)stack[stackLast]; | |
| } | |
| break; | |
| case LRI: | |
| case RLI: | |
| flags|=(DIRPROP_FLAG(ON)|DIRPROP_FLAG_LR(embeddingLevel)); | |
| levels[i]=NO_OVERRIDE(embeddingLevel); | |
| if(NO_OVERRIDE(embeddingLevel)!=NO_OVERRIDE(previousLevel)) { | |
| bracketProcessBoundary(&bracketData, lastCcPos, | |
| previousLevel, embeddingLevel); | |
| flags|=DIRPROP_FLAG_MULTI_RUNS; | |
| } | |
| previousLevel=embeddingLevel; | |
| /* (X5a, X5b) */ | |
| if(dirProp==LRI) | |
| /* least greater even level */ | |
| newLevel=(UBiDiLevel)((embeddingLevel+2)&~(UBIDI_LEVEL_OVERRIDE|1)); | |
| else | |
| /* least greater odd level */ | |
| newLevel=(UBiDiLevel)((NO_OVERRIDE(embeddingLevel)+1)|1); | |
| if(newLevel<=UBIDI_MAX_EXPLICIT_LEVEL && overflowIsolateCount==0 && | |
| overflowEmbeddingCount==0) { | |
| flags|=DIRPROP_FLAG(dirProp); | |
| lastCcPos=i; | |
| validIsolateCount++; | |
| if(validIsolateCount>pBiDi->isolateCount) | |
| pBiDi->isolateCount=validIsolateCount; | |
| embeddingLevel=newLevel; | |
| /* we can increment stackLast without checking because newLevel | |
| will exceed UBIDI_MAX_EXPLICIT_LEVEL before stackLast overflows */ | |
| stackLast++; | |
| stack[stackLast]=embeddingLevel+ISOLATE; | |
| bracketProcessLRI_RLI(&bracketData, embeddingLevel); | |
| } else { | |
| /* make it WS so that it is handled by adjustWSLevels() */ | |
| dirProps[i]=WS; | |
| overflowIsolateCount++; | |
| } | |
| break; | |
| case PDI: | |
| if(NO_OVERRIDE(embeddingLevel)!=NO_OVERRIDE(previousLevel)) { | |
| bracketProcessBoundary(&bracketData, lastCcPos, | |
| previousLevel, embeddingLevel); | |
| flags|=DIRPROP_FLAG_MULTI_RUNS; | |
| } | |
| /* (X6a) */ | |
| if(overflowIsolateCount) { | |
| overflowIsolateCount--; | |
| /* make it WS so that it is handled by adjustWSLevels() */ | |
| dirProps[i]=WS; | |
| } | |
| else if(validIsolateCount) { | |
| flags|=DIRPROP_FLAG(PDI); | |
| lastCcPos=i; | |
| overflowEmbeddingCount=0; | |
| while(stack[stackLast]<ISOLATE) /* pop embedding entries */ | |
| stackLast--; /* until the last isolate entry */ | |
| stackLast--; /* pop also the last isolate entry */ | |
| validIsolateCount--; | |
| bracketProcessPDI(&bracketData); | |
| } else | |
| /* make it WS so that it is handled by adjustWSLevels() */ | |
| dirProps[i]=WS; | |
| embeddingLevel=(UBiDiLevel)stack[stackLast]&~ISOLATE; | |
| flags|=(DIRPROP_FLAG(ON)|DIRPROP_FLAG_LR(embeddingLevel)); | |
| previousLevel=embeddingLevel; | |
| levels[i]=NO_OVERRIDE(embeddingLevel); | |
| break; | |
| case B: | |
| flags|=DIRPROP_FLAG(B); | |
| levels[i]=GET_PARALEVEL(pBiDi, i); | |
| if((i+1)<length) { | |
| if(text[i]==CR && text[i+1]==LF) | |
| break; /* skip CR when followed by LF */ | |
| overflowEmbeddingCount=overflowIsolateCount=0; | |
| validIsolateCount=0; | |
| stackLast=0; | |
| previousLevel=embeddingLevel=GET_PARALEVEL(pBiDi, i+1); | |
| stack[0]=embeddingLevel; /* initialize base entry to para level, no override, no isolate */ | |
| bracketProcessB(&bracketData, embeddingLevel); | |
| } | |
| break; | |
| case BN: | |
| /* BN, LRE, RLE, and PDF are supposed to be removed (X9) */ | |
| /* they will get their levels set correctly in adjustWSLevels() */ | |
| levels[i]=previousLevel; | |
| flags|=DIRPROP_FLAG(BN); | |
| break; | |
| default: | |
| /* all other types are normal characters and get the "real" level */ | |
| if(NO_OVERRIDE(embeddingLevel)!=NO_OVERRIDE(previousLevel)) { | |
| bracketProcessBoundary(&bracketData, lastCcPos, | |
| previousLevel, embeddingLevel); | |
| flags|=DIRPROP_FLAG_MULTI_RUNS; | |
| if(embeddingLevel&UBIDI_LEVEL_OVERRIDE) | |
| flags|=DIRPROP_FLAG_O(embeddingLevel); | |
| else | |
| flags|=DIRPROP_FLAG_E(embeddingLevel); | |
| } | |
| previousLevel=embeddingLevel; | |
| levels[i]=embeddingLevel; | |
| if(!bracketProcessChar(&bracketData, i)) | |
| return (UBiDiDirection)-1; | |
| /* the dirProp may have been changed in bracketProcessChar() */ | |
| flags|=DIRPROP_FLAG(dirProps[i]); | |
| break; | |
| } | |
| } | |
| if(flags&MASK_EMBEDDING) | |
| flags|=DIRPROP_FLAG_LR(pBiDi->paraLevel); | |
| if(pBiDi->orderParagraphsLTR && (flags&DIRPROP_FLAG(B))) | |
| flags|=DIRPROP_FLAG(L); | |
| /* again, determine if the text is mixed-directional or single-directional */ | |
| pBiDi->flags=flags; | |
| direction=directionFromFlags(pBiDi); | |
| } | |
| return direction; | |
| } | |
| /* | |
| * 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) { | |
| DirProp *dirProps=pBiDi->dirProps; | |
| UBiDiLevel *levels=pBiDi->levels; | |
| int32_t isolateCount=0; | |
| int32_t length=pBiDi->length; | |
| Flags flags=0; /* collect all directionalities in the text */ | |
| pBiDi->isolateCount=0; | |
| int32_t currentParaIndex = 0; | |
| int32_t currentParaLimit = pBiDi->paras[0].limit; | |
| int32_t currentParaLevel = pBiDi->paraLevel; | |
| for(int32_t i=0; i<length; ++i) { | |
| UBiDiLevel level=levels[i]; | |
| DirProp dirProp=dirProps[i]; | |
| if(dirProp==LRI || dirProp==RLI) { | |
| isolateCount++; | |
| if(isolateCount>pBiDi->isolateCount) | |
| pBiDi->isolateCount=isolateCount; | |
| } | |
| else if(dirProp==PDI) | |
| isolateCount--; | |
| else if(dirProp==B) | |
| isolateCount=0; | |
| // optimized version of int32_t currentParaLevel = GET_PARALEVEL(pBiDi, i); | |
| if (pBiDi->defaultParaLevel != 0 && | |
| i == currentParaLimit && (currentParaIndex + 1) < pBiDi->paraCount) { | |
| currentParaLevel = pBiDi->paras[++currentParaIndex].level; | |
| currentParaLimit = pBiDi->paras[currentParaIndex].limit; | |
| } | |
| UBiDiLevel overrideFlag = level & UBIDI_LEVEL_OVERRIDE; | |
| level &= ~UBIDI_LEVEL_OVERRIDE; | |
| if (level < currentParaLevel || UBIDI_MAX_EXPLICIT_LEVEL < level) { | |
| if (level == 0) { | |
| if (dirProp == B) { | |
| // Paragraph separators are ok with explicit level 0. | |
| // Prevents reordering of paragraphs. | |
| } else { | |
| // Treat explicit level 0 as a wildcard for the paragraph level. | |
| // Avoid making the caller guess what the paragraph level would be. | |
| level = (UBiDiLevel)currentParaLevel; | |
| levels[i] = level | overrideFlag; | |
| } | |
| } else { | |
| // 1 <= level < currentParaLevel or UBIDI_MAX_EXPLICIT_LEVEL < level | |
| /* level out of bounds */ | |
| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; | |
| return UBIDI_LTR; | |
| } | |
| } | |
| if (overrideFlag != 0) { | |
| /* keep the override flag in levels[i] but adjust the flags */ | |
| flags|=DIRPROP_FLAG_O(level); | |
| } else { | |
| /* set the flags */ | |
| flags|=DIRPROP_FLAG_E(level)|DIRPROP_FLAG(dirProp); | |
| } | |
| } | |
| 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(pBiDi); | |
| } | |
| /****************************************************************** | |
| The Properties state machine table | |
| ******************************************************************* | |
| All table cells are 8 bits: | |
| bits 0..4: next state | |
| bits 5..7: action to perform (if > 0) | |
| Cells may be of format "n" where n represents the next state | |
| (except for the rightmost column). | |
| Cells may also be of format "s(x,y)" where x represents an action | |
| to perform and y represents the next state. | |
| ******************************************************************* | |
| Definitions and type for properties state table | |
| ******************************************************************* | |
| */ | |
| #define IMPTABPROPS_COLUMNS 16 | |
| #define IMPTABPROPS_RES (IMPTABPROPS_COLUMNS - 1) | |
| #define GET_STATEPROPS(cell) ((cell)&0x1f) | |
| #define GET_ACTIONPROPS(cell) ((cell)>>5) | |
| #define s(action, newState) ((uint8_t)(newState+(action<<5))) | |
| static const uint8_t groupProp[] = /* dirProp regrouped */ | |
| { | |
| /* L R EN ES ET AN CS B S WS ON LRE LRO AL RLE RLO PDF NSM BN FSI LRI RLI PDI ENL ENR */ | |
| 0, 1, 2, 7, 8, 3, 9, 6, 5, 4, 4, 10, 10, 12, 10, 10, 10, 11, 10, 4, 4, 4, 4, 13, 14 | |
| }; | |
| enum { DirProp_L=0, DirProp_R=1, DirProp_EN=2, DirProp_AN=3, DirProp_ON=4, DirProp_S=5, DirProp_B=6 }; /* reduced dirProp */ | |
| /****************************************************************** | |
| PROPERTIES STATE TABLE | |
| In table impTabProps, | |
| - the ON column regroups ON and WS, FSI, RLI, LRI and PDI | |
| - the BN column regroups BN, LRE, RLE, LRO, RLO, PDF | |
| - the Res column is the reduced property assigned to a run | |
| Action 1: process current run1, init new run1 | |
| 2: init new run2 | |
| 3: process run1, process run2, init new run1 | |
| 4: process run1, set run1=run2, init new run2 | |
| Notes: | |
| 1) This table is used in resolveImplicitLevels(). | |
| 2) This table triggers actions when there is a change in the Bidi | |
| property of incoming characters (action 1). | |
| 3) Most such property sequences are processed immediately (in | |
| fact, passed to processPropertySeq(). | |
| 4) However, numbers are assembled as one sequence. This means | |
| that undefined situations (like CS following digits, until | |
| it is known if the next char will be a digit) are held until | |
| following chars define them. | |
| Example: digits followed by CS, then comes another CS or ON; | |
| the digits will be processed, then the CS assigned | |
| as the start of an ON sequence (action 3). | |
| 5) There are cases where more than one sequence must be | |
| processed, for instance digits followed by CS followed by L: | |
| the digits must be processed as one sequence, and the CS | |
| must be processed as an ON sequence, all this before starting | |
| assembling chars for the opening L sequence. | |
| */ | |
| static const uint8_t impTabProps[][IMPTABPROPS_COLUMNS] = | |
| { | |
| /* L , R , EN , AN , ON , S , B , ES , ET , CS , BN , NSM , AL , ENL , ENR , Res */ | |
| /* 0 Init */ { 1 , 2 , 4 , 5 , 7 , 15 , 17 , 7 , 9 , 7 , 0 , 7 , 3 , 18 , 21 , DirProp_ON }, | |
| /* 1 L */ { 1 , s(1,2), s(1,4), s(1,5), s(1,7),s(1,15),s(1,17), s(1,7), s(1,9), s(1,7), 1 , 1 , s(1,3),s(1,18),s(1,21), DirProp_L }, | |
| /* 2 R */ { s(1,1), 2 , s(1,4), s(1,5), s(1,7),s(1,15),s(1,17), s(1,7), s(1,9), s(1,7), 2 , 2 , s(1,3),s(1,18),s(1,21), DirProp_R }, | |
| /* 3 AL */ { s(1,1), s(1,2), s(1,6), s(1,6), s(1,8),s(1,16),s(1,17), s(1,8), s(1,8), s(1,8), 3 , 3 , 3 ,s(1,18),s(1,21), DirProp_R }, | |
| /* 4 EN */ { s(1,1), s(1,2), 4 , s(1,5), s(1,7),s(1,15),s(1,17),s(2,10), 11 ,s(2,10), 4 , 4 , s(1,3), 18 , 21 , DirProp_EN }, | |
| /* 5 AN */ { s(1,1), s(1,2), s(1,4), 5 , s(1,7),s(1,15),s(1,17), s(1,7), s(1,9),s(2,12), 5 , 5 , s(1,3),s(1,18),s(1,21), DirProp_AN }, | |
| /* 6 AL:EN/AN */ { s(1,1), s(1,2), 6 , 6 , s(1,8),s(1,16),s(1,17), s(1,8), s(1,8),s(2,13), 6 , 6 , s(1,3), 18 , 21 , DirProp_AN }, | |
| /* 7 ON */ { s(1,1), s(1,2), s(1,4), s(1,5), 7 ,s(1,15),s(1,17), 7 ,s(2,14), 7 , 7 , 7 , s(1,3),s(1,18),s(1,21), DirProp_ON }, | |
| /* 8 AL:ON */ { s(1,1), s(1,2), s(1,6), s(1,6), 8 ,s(1,16),s(1,17), 8 , 8 , 8 , 8 , 8 , s(1,3),s(1,18),s(1,21), DirProp_ON }, | |
| /* 9 ET */ { s(1,1), s(1,2), 4 , s(1,5), 7 ,s(1,15),s(1,17), 7 , 9 , 7 , 9 , 9 , s(1,3), 18 , 21 , DirProp_ON }, | |
| /*10 EN+ES/CS */ { s(3,1), s(3,2), 4 , s(3,5), s(4,7),s(3,15),s(3,17), s(4,7),s(4,14), s(4,7), 10 , s(4,7), s(3,3), 18 , 21 , DirProp_EN }, | |
| /*11 EN+ET */ { s(1,1), s(1,2), 4 , s(1,5), s(1,7),s(1,15),s(1,17), s(1,7), 11 , s(1,7), 11 , 11 , s(1,3), 18 , 21 , DirProp_EN }, | |
| /*12 AN+CS */ { s(3,1), s(3,2), s(3,4), 5 , s(4,7),s(3,15),s(3,17), s(4,7),s(4,14), s(4,7), 12 , s(4,7), s(3,3),s(3,18),s(3,21), DirProp_AN }, | |
| /*13 AL:EN/AN+CS */ { s(3,1), s(3,2), 6 , 6 , s(4,8),s(3,16),s(3,17), s(4,8), s(4,8), s(4,8), 13 , s(4,8), s(3,3), 18 , 21 , DirProp_AN }, | |
| /*14 ON+ET */ { s(1,1), s(1,2), s(4,4), s(1,5), 7 ,s(1,15),s(1,17), 7 , 14 , 7 , 14 , 14 , s(1,3),s(4,18),s(4,21), DirProp_ON }, | |
| /*15 S */ { s(1,1), s(1,2), s(1,4), s(1,5), s(1,7), 15 ,s(1,17), s(1,7), s(1,9), s(1,7), 15 , s(1,7), s(1,3),s(1,18),s(1,21), DirProp_S }, | |
| /*16 AL:S */ { s(1,1), s(1,2), s(1,6), s(1,6), s(1,8), 16 ,s(1,17), s(1,8), s(1,8), s(1,8), 16 , s(1,8), s(1,3),s(1,18),s(1,21), DirProp_S }, | |
| /*17 B */ { s(1,1), s(1,2), s(1,4), s(1,5), s(1,7),s(1,15), 17 , s(1,7), s(1,9), s(1,7), 17 , s(1,7), s(1,3),s(1,18),s(1,21), DirProp_B }, | |
| /*18 ENL */ { s(1,1), s(1,2), 18 , s(1,5), s(1,7),s(1,15),s(1,17),s(2,19), 20 ,s(2,19), 18 , 18 , s(1,3), 18 , 21 , DirProp_L }, | |
| /*19 ENL+ES/CS */ { s(3,1), s(3,2), 18 , s(3,5), s(4,7),s(3,15),s(3,17), s(4,7),s(4,14), s(4,7), 19 , s(4,7), s(3,3), 18 , 21 , DirProp_L }, | |
| /*20 ENL+ET */ { s(1,1), s(1,2), 18 , s(1,5), s(1,7),s(1,15),s(1,17), s(1,7), 20 , s(1,7), 20 , 20 , s(1,3), 18 , 21 , DirProp_L }, | |
| /*21 ENR */ { s(1,1), s(1,2), 21 , s(1,5), s(1,7),s(1,15),s(1,17),s(2,22), 23 ,s(2,22), 21 , 21 , s(1,3), 18 , 21 , DirProp_AN }, | |
| /*22 ENR+ES/CS */ { s(3,1), s(3,2), 21 , s(3,5), s(4,7),s(3,15),s(3,17), s(4,7),s(4,14), s(4,7), 22 , s(4,7), s(3,3), 18 , 21 , DirProp_AN }, | |
| /*23 ENR+ET */ { s(1,1), s(1,2), 21 , s(1,5), s(1,7),s(1,15),s(1,17), s(1,7), 23 , s(1,7), 23 , 23 , s(1,3), 18 , 21 , DirProp_AN } | |
| }; | |
| /* we must undef macro s because the levels tables have a different | |
| * structure (4 bits for action and 4 bits for next state. | |
| */ | |
| #undef s | |
| /****************************************************************** | |
| The levels state machine tables | |
| ******************************************************************* | |
| All table cells are 8 bits: | |
| bits 0..3: next state | |
| bits 4..7: action to perform (if > 0) | |
| Cells may be of format "n" where n represents the next state | |
| (except for the rightmost column). | |
| Cells may also be of format "s(x,y)" where x represents an action | |
| to perform and y represents the next state. | |
| This format limits each table to 16 states each and to 15 actions. | |
| ******************************************************************* | |
| Definitions and type for levels state tables | |
| ******************************************************************* | |
| */ | |
| #define IMPTABLEVELS_COLUMNS (DirProp_B + 2) | |
| #define IMPTABLEVELS_RES (IMPTABLEVELS_COLUMNS - 1) | |
| #define GET_STATE(cell) ((cell)&0x0f) | |
| #define GET_ACTION(cell) ((cell)>>4) | |
| #define s(action, newState) ((uint8_t)(newState+(action<<4))) | |
| typedef uint8_t ImpTab[][IMPTABLEVELS_COLUMNS]; | |
| typedef uint8_t ImpAct[]; | |
| /* FOOD FOR THOUGHT: each ImpTab should have its associated ImpAct, | |
| * instead of having a pair of ImpTab and a pair of ImpAct. | |
| */ | |
| typedef struct ImpTabPair { | |
| const void * pImpTab[2]; | |
| const void * pImpAct[2]; | |
| } ImpTabPair; | |
| /****************************************************************** | |
| LEVELS STATE TABLES | |
| In all levels state tables, | |
| - state 0 is the initial state | |
| - the Res column is the increment to add to the text level | |
| for this property sequence. | |
| The impAct arrays for each table of a pair map the local action | |
| numbers of the table to the total list of actions. For instance, | |
| action 2 in a given table corresponds to the action number which | |
| appears in entry [2] of the impAct array for that table. | |
| The first entry of all impAct arrays must be 0. | |
| Action 1: init conditional sequence | |
| 2: prepend conditional sequence to current sequence | |
| 3: set ON sequence to new level - 1 | |
| 4: init EN/AN/ON sequence | |
| 5: fix EN/AN/ON sequence followed by R | |
| 6: set previous level sequence to level 2 | |
| Notes: | |
| 1) These tables are used in processPropertySeq(). The input | |
| is property sequences as determined by resolveImplicitLevels. | |
| 2) Most such property sequences are processed immediately | |
| (levels are assigned). | |
| 3) However, some sequences cannot be assigned a final level till | |
| one or more following sequences are received. For instance, | |
| ON following an R sequence within an even-level paragraph. | |
| If the following sequence is R, the ON sequence will be | |
| assigned basic run level+1, and so will the R sequence. | |
| 4) S is generally handled like ON, since its level will be fixed | |
| to paragraph level in adjustWSLevels(). | |
| */ | |
| static const ImpTab impTabL_DEFAULT = /* Even paragraph level */ | |
| /* In this table, conditional sequences receive the lower possible level | |
| until proven otherwise. | |
| */ | |
| { | |
| /* L , R , EN , AN , ON , S , B , Res */ | |
| /* 0 : init */ { 0 , 1 , 0 , 2 , 0 , 0 , 0 , 0 }, | |
| /* 1 : R */ { 0 , 1 , 3 , 3 , s(1,4), s(1,4), 0 , 1 }, | |
| /* 2 : AN */ { 0 , 1 , 0 , 2 , s(1,5), s(1,5), 0 , 2 }, | |
| /* 3 : R+EN/AN */ { 0 , 1 , 3 , 3 , s(1,4), s(1,4), 0 , 2 }, | |
| /* 4 : R+ON */ { 0 , s(2,1), s(3,3), s(3,3), 4 , 4 , 0 , 0 }, | |
| /* 5 : AN+ON */ { 0 , s(2,1), 0 , s(3,2), 5 , 5 , 0 , 0 } | |
| }; | |
| static const ImpTab impTabR_DEFAULT = /* Odd paragraph level */ | |
| /* In this table, conditional sequences receive the lower possible level | |
| until proven otherwise. | |
| */ | |
| { | |
| /* L , R , EN , AN , ON , S , B , Res */ | |
| /* 0 : init */ { 1 , 0 , 2 , 2 , 0 , 0 , 0 , 0 }, | |
| /* 1 : L */ { 1 , 0 , 1 , 3 , s(1,4), s(1,4), 0 , 1 }, | |
| /* 2 : EN/AN */ { 1 , 0 , 2 , 2 , 0 , 0 , 0 , 1 }, | |
| /* 3 : L+AN */ { 1 , 0 , 1 , 3 , 5 , 5 , 0 , 1 }, | |
| /* 4 : L+ON */ { s(2,1), 0 , s(2,1), 3 , 4 , 4 , 0 , 0 }, | |
| /* 5 : L+AN+ON */ { 1 , 0 , 1 , 3 , 5 , 5 , 0 , 0 } | |
| }; | |
| static const ImpAct impAct0 = {0,1,2,3,4}; | |
| static const ImpTabPair impTab_DEFAULT = {{&impTabL_DEFAULT, | |
| &impTabR_DEFAULT}, | |
| {&impAct0, &impAct0}}; | |
| static const ImpTab impTabL_NUMBERS_SPECIAL = /* Even paragraph level */ | |
| /* In this table, conditional sequences receive the lower possible level | |
| until proven otherwise. | |
| */ | |
| { | |
| /* L , R , EN , AN , ON , S , B , Res */ | |
| /* 0 : init */ { 0 , 2 , s(1,1), s(1,1), 0 , 0 , 0 , 0 }, | |
| /* 1 : L+EN/AN */ { 0 , s(4,2), 1 , 1 , 0 , 0 , 0 , 0 }, | |
| /* 2 : R */ { 0 , 2 , 4 , 4 , s(1,3), s(1,3), 0 , 1 }, | |
| /* 3 : R+ON */ { 0 , s(2,2), s(3,4), s(3,4), 3 , 3 , 0 , 0 }, | |
| /* 4 : R+EN/AN */ { 0 , 2 , 4 , 4 , s(1,3), s(1,3), 0 , 2 } | |
| }; | |
| static const ImpTabPair impTab_NUMBERS_SPECIAL = {{&impTabL_NUMBERS_SPECIAL, | |
| &impTabR_DEFAULT}, | |
| {&impAct0, &impAct0}}; | |
| static const ImpTab impTabL_GROUP_NUMBERS_WITH_R = | |
| /* In this table, EN/AN+ON sequences receive levels as if associated with R | |
| until proven that there is L or sor/eor on both sides. AN is handled like EN. | |
| */ | |
| { | |
| /* L , R , EN , AN , ON , S , B , Res */ | |
| /* 0 init */ { 0 , 3 , s(1,1), s(1,1), 0 , 0 , 0 , 0 }, | |
| /* 1 EN/AN */ { s(2,0), 3 , 1 , 1 , 2 , s(2,0), s(2,0), 2 }, | |
| /* 2 EN/AN+ON */ { s(2,0), 3 , 1 , 1 , 2 , s(2,0), s(2,0), 1 }, | |
| /* 3 R */ { 0 , 3 , 5 , 5 , s(1,4), 0 , 0 , 1 }, | |
| /* 4 R+ON */ { s(2,0), 3 , 5 , 5 , 4 , s(2,0), s(2,0), 1 }, | |
| /* 5 R+EN/AN */ { 0 , 3 , 5 , 5 , s(1,4), 0 , 0 , 2 } | |
| }; | |
| static const ImpTab impTabR_GROUP_NUMBERS_WITH_R = | |
| /* In this table, EN/AN+ON sequences receive levels as if associated with R | |
| until proven that there is L on both sides. AN is handled like EN. | |
| */ | |
| { | |
| /* L , R , EN , AN , ON , S , B , Res */ | |
| /* 0 init */ { 2 , 0 , 1 , 1 , 0 , 0 , 0 , 0 }, | |
| /* 1 EN/AN */ { 2 , 0 , 1 , 1 , 0 , 0 , 0 , 1 }, | |
| /* 2 L */ { 2 , 0 , s(1,4), s(1,4), s(1,3), 0 , 0 , 1 }, | |
| /* 3 L+ON */ { s(2,2), 0 , 4 , 4 , 3 , 0 , 0 , 0 }, | |
| /* 4 L+EN/AN */ { s(2,2), 0 , 4 , 4 , 3 , 0 , 0 , 1 } | |
| }; | |
| static const ImpTabPair impTab_GROUP_NUMBERS_WITH_R = { | |
| {&impTabL_GROUP_NUMBERS_WITH_R, | |
| &impTabR_GROUP_NUMBERS_WITH_R}, | |
| {&impAct0, &impAct0}}; | |
| static const ImpTab impTabL_INVERSE_NUMBERS_AS_L = | |
| /* This table is identical to the Default LTR table except that EN and AN are | |
| handled like L. | |
| */ | |
| { | |
| /* L , R , EN , AN , ON , S , B , Res */ | |
| /* 0 : init */ { 0 , 1 , 0 , 0 , 0 , 0 , 0 , 0 }, | |
| /* 1 : R */ { 0 , 1 , 0 , 0 , s(1,4), s(1,4), 0 , 1 }, | |
| /* 2 : AN */ { 0 , 1 , 0 , 0 , s(1,5), s(1,5), 0 , 2 }, | |
| /* 3 : R+EN/AN */ { 0 , 1 , 0 , 0 , s(1,4), s(1,4), 0 , 2 }, | |
| /* 4 : R+ON */ { s(2,0), 1 , s(2,0), s(2,0), 4 , 4 , s(2,0), 1 }, | |
| /* 5 : AN+ON */ { s(2,0), 1 , s(2,0), s(2,0), 5 , 5 , s(2,0), 1 } | |
| }; | |
| static const ImpTab impTabR_INVERSE_NUMBERS_AS_L = | |
| /* This table is identical to the Default RTL table except that EN and AN are | |
| handled like L. | |
| */ | |
| { | |
| /* L , R , EN , AN , ON , S , B , Res */ | |
| /* 0 : init */ { 1 , 0 , 1 , 1 , 0 , 0 , 0 , 0 }, | |
| /* 1 : L */ { 1 , 0 , 1 , 1 , s(1,4), s(1,4), 0 , 1 }, | |
| /* 2 : EN/AN */ { 1 , 0 , 1 , 1 , 0 , 0 , 0 , 1 }, | |
| /* 3 : L+AN */ { 1 , 0 , 1 , 1 , 5 , 5 , 0 , 1 }, | |
| /* 4 : L+ON */ { s(2,1), 0 , s(2,1), s(2,1), 4 , 4 , 0 , 0 }, | |
| /* 5 : L+AN+ON */ { 1 , 0 , 1 , 1 , 5 , 5 , 0 , 0 } | |
| }; | |
| static const ImpTabPair impTab_INVERSE_NUMBERS_AS_L = { | |
| {&impTabL_INVERSE_NUMBERS_AS_L, | |
| &impTabR_INVERSE_NUMBERS_AS_L}, | |
| {&impAct0, &impAct0}}; | |
| static const ImpTab impTabR_INVERSE_LIKE_DIRECT = /* Odd paragraph level */ | |
| /* In this table, conditional sequences receive the lower possible level | |
| until proven otherwise. | |
| */ | |
| { | |
| /* L , R , EN , AN , ON , S , B , Res */ | |
| /* 0 : init */ { 1 , 0 , 2 , 2 , 0 , 0 , 0 , 0 }, | |
| /* 1 : L */ { 1 , 0 , 1 , 2 , s(1,3), s(1,3), 0 , 1 }, | |
| /* 2 : EN/AN */ { 1 , 0 , 2 , 2 , 0 , 0 , 0 , 1 }, | |
| /* 3 : L+ON */ { s(2,1), s(3,0), 6 , 4 , 3 , 3 , s(3,0), 0 }, | |
| /* 4 : L+ON+AN */ { s(2,1), s(3,0), 6 , 4 , 5 , 5 , s(3,0), 3 }, | |
| /* 5 : L+AN+ON */ { s(2,1), s(3,0), 6 , 4 , 5 , 5 , s(3,0), 2 }, | |
| /* 6 : L+ON+EN */ { s(2,1), s(3,0), 6 , 4 , 3 , 3 , s(3,0), 1 } | |
| }; | |
| static const ImpAct impAct1 = {0,1,13,14}; | |
| /* FOOD FOR THOUGHT: in LTR table below, check case "JKL 123abc" | |
| */ | |
| static const ImpTabPair impTab_INVERSE_LIKE_DIRECT = { | |
| {&impTabL_DEFAULT, | |
| &impTabR_INVERSE_LIKE_DIRECT}, | |
| {&impAct0, &impAct1}}; | |
| static const ImpTab impTabL_INVERSE_LIKE_DIRECT_WITH_MARKS = | |
| /* The case handled in this table is (visually): R EN L | |
| */ | |
| { | |
| /* L , R , EN , AN , ON , S , B , Res */ | |
| /* 0 : init */ { 0 , s(6,3), 0 , 1 , 0 , 0 , 0 , 0 }, | |
| /* 1 : L+AN */ { 0 , s(6,3), 0 , 1 , s(1,2), s(3,0), 0 , 4 }, | |
| /* 2 : L+AN+ON */ { s(2,0), s(6,3), s(2,0), 1 , 2 , s(3,0), s(2,0), 3 }, | |
| /* 3 : R */ { 0 , s(6,3), s(5,5), s(5,6), s(1,4), s(3,0), 0 , 3 }, | |
| /* 4 : R+ON */ { s(3,0), s(4,3), s(5,5), s(5,6), 4 , s(3,0), s(3,0), 3 }, | |
| /* 5 : R+EN */ { s(3,0), s(4,3), 5 , s(5,6), s(1,4), s(3,0), s(3,0), 4 }, | |
| /* 6 : R+AN */ { s(3,0), s(4,3), s(5,5), 6 , s(1,4), s(3,0), s(3,0), 4 } | |
| }; | |
| static const ImpTab impTabR_INVERSE_LIKE_DIRECT_WITH_MARKS = | |
| /* The cases handled in this table are (visually): R EN L | |
| R L AN L | |
| */ | |
| { | |
| /* L , R , EN , AN , ON , S , B , Res */ | |
| /* 0 : init */ { s(1,3), 0 , 1 , 1 , 0 , 0 , 0 , 0 }, | |
| /* 1 : R+EN/AN */ { s(2,3), 0 , 1 , 1 , 2 , s(4,0), 0 , 1 }, | |
| /* 2 : R+EN/AN+ON */ { s(2,3), 0 , 1 , 1 , 2 , s(4,0), 0 , 0 }, | |
| /* 3 : L */ { 3 , 0 , 3 , s(3,6), s(1,4), s(4,0), 0 , 1 }, | |
| /* 4 : L+ON */ { s(5,3), s(4,0), 5 , s(3,6), 4 , s(4,0), s(4,0), 0 }, | |
| /* 5 : L+ON+EN */ { s(5,3), s(4,0), 5 , s(3,6), 4 , s(4,0), s(4,0), 1 }, | |
| /* 6 : L+AN */ { s(5,3), s(4,0), 6 , 6 , 4 , s(4,0), s(4,0), 3 } | |
| }; | |
| static const ImpAct impAct2 = {0,1,2,5,6,7,8}; | |
| static const ImpAct impAct3 = {0,1,9,10,11,12}; | |
| static const ImpTabPair impTab_INVERSE_LIKE_DIRECT_WITH_MARKS = { | |
| {&impTabL_INVERSE_LIKE_DIRECT_WITH_MARKS, | |
| &impTabR_INVERSE_LIKE_DIRECT_WITH_MARKS}, | |
| {&impAct2, &impAct3}}; | |
| static const ImpTabPair impTab_INVERSE_FOR_NUMBERS_SPECIAL = { | |
| {&impTabL_NUMBERS_SPECIAL, | |
| &impTabR_INVERSE_LIKE_DIRECT}, | |
| {&impAct0, &impAct1}}; | |
| static const ImpTab impTabL_INVERSE_FOR_NUMBERS_SPECIAL_WITH_MARKS = | |
| /* The case handled in this table is (visually): R EN L | |
| */ | |
| { | |
| /* L , R , EN , AN , ON , S , B , Res */ | |
| /* 0 : init */ { 0 , s(6,2), 1 , 1 , 0 , 0 , 0 , 0 }, | |
| /* 1 : L+EN/AN */ { 0 , s(6,2), 1 , 1 , 0 , s(3,0), 0 , 4 }, | |
| /* 2 : R */ { 0 , s(6,2), s(5,4), s(5,4), s(1,3), s(3,0), 0 , 3 }, | |
| /* 3 : R+ON */ { s(3,0), s(4,2), s(5,4), s(5,4), 3 , s(3,0), s(3,0), 3 }, | |
| /* 4 : R+EN/AN */ { s(3,0), s(4,2), 4 , 4 , s(1,3), s(3,0), s(3,0), 4 } | |
| }; | |
| static const ImpTabPair impTab_INVERSE_FOR_NUMBERS_SPECIAL_WITH_MARKS = { | |
| {&impTabL_INVERSE_FOR_NUMBERS_SPECIAL_WITH_MARKS, | |
| &impTabR_INVERSE_LIKE_DIRECT_WITH_MARKS}, | |
| {&impAct2, &impAct3}}; | |
| #undef s | |
| typedef struct { | |
| const ImpTab * pImpTab; /* level table pointer */ | |
| const ImpAct * pImpAct; /* action map array */ | |
| int32_t startON; /* start of ON sequence */ | |
| int32_t startL2EN; /* start of level 2 sequence */ | |
| int32_t lastStrongRTL; /* index of last found R or AL */ | |
| int32_t state; /* current state */ | |
| int32_t runStart; /* start position of the run */ | |
| UBiDiLevel runLevel; /* run level before implicit solving */ | |
| } LevState; | |
| /*------------------------------------------------------------------------*/ | |
| static void | |
| addPoint(UBiDi *pBiDi, int32_t pos, int32_t flag) | |
| /* param pos: position where to insert | |
| param flag: one of LRM_BEFORE, LRM_AFTER, RLM_BEFORE, RLM_AFTER | |
| */ | |
| { | |
| #define FIRSTALLOC 10 | |
| Point point; | |
| InsertPoints * pInsertPoints=&(pBiDi->insertPoints); | |
| if (pInsertPoints->capacity == 0) | |
| { | |
| pInsertPoints->points=static_cast<Point *>(uprv_malloc(sizeof(Point)*FIRSTALLOC)); | |
| if (pInsertPoints->points == NULL) | |
| { | |
| pInsertPoints->errorCode=U_MEMORY_ALLOCATION_ERROR; | |
| return; | |
| } | |
| pInsertPoints->capacity=FIRSTALLOC; | |
| } | |
| if (pInsertPoints->size >= pInsertPoints->capacity) /* no room for new point */ | |
| { | |
| Point * savePoints=pInsertPoints->points; | |
| pInsertPoints->points=static_cast<Point *>(uprv_realloc(pInsertPoints->points, | |
| pInsertPoints->capacity*2*sizeof(Point))); | |
| if (pInsertPoints->points == NULL) | |
| { | |
| pInsertPoints->points=savePoints; | |
| pInsertPoints->errorCode=U_MEMORY_ALLOCATION_ERROR; | |
| return; | |
| } | |
| else pInsertPoints->capacity*=2; | |
| } | |
| point.pos=pos; | |
| point.flag=flag; | |
| pInsertPoints->points[pInsertPoints->size]=point; | |
| pInsertPoints->size++; | |
| #undef FIRSTALLOC | |
| } | |
| static void | |
| setLevelsOutsideIsolates(UBiDi *pBiDi, int32_t start, int32_t limit, UBiDiLevel level) | |
| { | |
| DirProp *dirProps=pBiDi->dirProps, dirProp; | |
| UBiDiLevel *levels=pBiDi->levels; | |
| int32_t isolateCount=0, k; | |
| for(k=start; k<limit; k++) { | |
| dirProp=dirProps[k]; | |
| if(dirProp==PDI) | |
| isolateCount--; | |
| if(isolateCount==0) | |
| levels[k]=level; | |
| if(dirProp==LRI || dirProp==RLI) | |
| isolateCount++; | |
| } | |
| } | |
| /* perform rules (Wn), (Nn), and (In) on a run of the text ------------------ */ | |
| /* | |
| * This implementation of the (Wn) rules applies all rules in one pass. | |
| * In order to do so, it needs a look-ahead of typically 1 character | |
| * (except for W5: sequences of ET) and keeps track of changes | |
| * in a rule Wp that affect a later Wq (p<q). | |
| * | |
| * The (Nn) and (In) rules are also performed in that same single loop, | |
| * but effectively one iteration behind for white space. | |
| * | |
| * Since all implicit rules are performed in one step, it is not necessary | |
| * to actually store the intermediate directional properties in dirProps[]. | |
| */ | |
| static void | |
| processPropertySeq(UBiDi *pBiDi, LevState *pLevState, uint8_t _prop, | |
| int32_t start, int32_t limit) { | |
| uint8_t cell, oldStateSeq, actionSeq; | |
| const ImpTab * pImpTab=pLevState->pImpTab; | |
| const ImpAct * pImpAct=pLevState->pImpAct; | |
| UBiDiLevel * levels=pBiDi->levels; | |
| UBiDiLevel level, addLevel; | |
| InsertPoints * pInsertPoints; | |
| int32_t start0, k; | |
| start0=start; /* save original start position */ | |
| oldStateSeq=(uint8_t)pLevState->state; | |
| cell=(*pImpTab)[oldStateSeq][_prop]; | |
| pLevState->state=GET_STATE(cell); /* isolate the new state */ | |
| actionSeq=(*pImpAct)[GET_ACTION(cell)]; /* isolate the action */ | |
| addLevel=(*pImpTab)[pLevState->state][IMPTABLEVELS_RES]; | |
| if(actionSeq) { | |
| switch(actionSeq) { | |
| case 1: /* init ON seq */ | |
| pLevState->startON=start0; | |
| break; | |
| case 2: /* prepend ON seq to current seq */ | |
| start=pLevState->startON; | |
| break; | |
| case 3: /* EN/AN after R+ON */ | |
| level=pLevState->runLevel+1; | |
| setLevelsOutsideIsolates(pBiDi, pLevState->startON, start0, level); | |
| break; | |
| case 4: /* EN/AN before R for NUMBERS_SPECIAL */ | |
| level=pLevState->runLevel+2; | |
| setLevelsOutsideIsolates(pBiDi, pLevState->startON, start0, level); | |
| break; | |
| case 5: /* L or S after possible relevant EN/AN */ | |
| /* check if we had EN after R/AL */ | |
| if (pLevState->startL2EN >= 0) { | |
| addPoint(pBiDi, pLevState->startL2EN, LRM_BEFORE); | |
| } | |
| pLevState->startL2EN=-1; /* not within previous if since could also be -2 */ | |
| /* check if we had any relevant EN/AN after R/AL */ | |
| pInsertPoints=&(pBiDi->insertPoints); | |
| if ((pInsertPoints->capacity == 0) || | |
| (pInsertPoints->size <= pInsertPoints->confirmed)) | |
| { | |
| /* nothing, just clean up */ | |
| pLevState->lastStrongRTL=-1; | |
| /* check if we have a pending conditional segment */ | |
| level=(*pImpTab)[oldStateSeq][IMPTABLEVELS_RES]; | |
| if ((level & 1) && (pLevState->startON > 0)) { /* after ON */ | |
| start=pLevState->startON; /* reset to basic run level */ | |
| } | |
| if (_prop == DirProp_S) /* add LRM before S */ | |
| { | |
| addPoint(pBiDi, start0, LRM_BEFORE); | |
| pInsertPoints->confirmed=pInsertPoints->size; | |
| } | |
| break; | |
| } | |
| /* reset previous RTL cont to level for LTR text */ | |
| for (k=pLevState->lastStrongRTL+1; k<start0; k++) | |
| { | |
| /* reset odd level, leave runLevel+2 as is */ | |
| levels[k]=(levels[k] - 2) & ~1; | |
| } | |
| /* mark insert points as confirmed */ | |
| pInsertPoints->confirmed=pInsertPoints->size; | |
| pLevState->lastStrongRTL=-1; | |
| if (_prop == DirProp_S) /* add LRM before S */ | |
| { | |
| addPoint(pBiDi, start0, LRM_BEFORE); | |
| pInsertPoints->confirmed=pInsertPoints->size; | |
| } | |
| break; | |
| case 6: /* R/AL after possible relevant EN/AN */ | |
| /* just clean up */ | |
| pInsertPoints=&(pBiDi->insertPoints); | |
| if (pInsertPoints->capacity > 0) | |
| /* remove all non confirmed insert points */ | |
| pInsertPoints->size=pInsertPoints->confirmed; | |
| pLevState->startON=-1; | |
| pLevState->startL2EN=-1; | |
| pLevState->lastStrongRTL=limit - 1; | |
| break; | |
| case 7: /* EN/AN after R/AL + possible cont */ | |
| /* check for real AN */ | |
| if ((_prop == DirProp_AN) && (pBiDi->dirProps[start0] == AN) && | |
| (pBiDi->reorderingMode!=UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL)) | |
| { | |
| /* real AN */ | |
| if (pLevState->startL2EN == -1) /* if no relevant EN already found */ | |
| { | |
| /* just note the righmost digit as a strong RTL */ | |
| pLevState->lastStrongRTL=limit - 1; | |
| break; | |
| } | |
| if (pLevState->startL2EN >= 0) /* after EN, no AN */ | |
| { | |
| addPoint(pBiDi, pLevState->startL2EN, LRM_BEFORE); | |
| pLevState->startL2EN=-2; | |
| } | |
| /* note AN */ | |
| addPoint(pBiDi, start0, LRM_BEFORE); | |
| break; | |
| } | |
| /* if first EN/AN after R/AL */ | |
| if (pLevState->startL2EN == -1) { | |
| pLevState->startL2EN=start0; | |
| } | |
| break; | |
| case 8: /* note location of latest R/AL */ | |
| pLevState->lastStrongRTL=limit - 1; | |
| pLevState->startON=-1; | |
| break; | |
| case 9: /* L after R+ON/EN/AN */ | |
| /* include possible adjacent number on the left */ | |
| for (k=start0-1; k>=0 && !(levels[k]&1); k--); | |
| if(k>=0) { | |
| addPoint(pBiDi, k, RLM_BEFORE); /* add RLM before */ | |
| pInsertPoints=&(pBiDi->insertPoints); | |
| pInsertPoints->confirmed=pInsertPoints->size; /* confirm it */ | |
| } | |
| pLevState->startON=start0; | |
| break; | |
| case 10: /* AN after L */ | |
| /* AN numbers between L text on both sides may be trouble. */ | |
| /* tentatively bracket with LRMs; will be confirmed if followed by L */ | |
| addPoint(pBiDi, start0, LRM_BEFORE); /* add LRM before */ | |
| addPoint(pBiDi, start0, LRM_AFTER); /* add LRM after */ | |
| break; | |
| case 11: /* R after L+ON/EN/AN */ | |
| /* false alert, infirm LRMs around previous AN */ | |
| pInsertPoints=&(pBiDi->insertPoints); | |
| pInsertPoints->size=pInsertPoints->confirmed; | |
| if (_prop == DirProp_S) /* add RLM before S */ | |
| { | |
| addPoint(pBiDi, start0, RLM_BEFORE); | |
| pInsertPoints->confirmed=pInsertPoints->size; | |
| } | |
| break; | |
| case 12: /* L after L+ON/AN */ | |
| level=pLevState->runLevel + addLevel; | |
| for(k=pLevState->startON; k<start0; k++) { | |
| if (levels[k]<level) | |
| levels[k]=level; | |
| } | |
| pInsertPoints=&(pBiDi->insertPoints); | |
| pInsertPoints->confirmed=pInsertPoints->size; /* confirm inserts */ | |
| pLevState->startON=start0; | |
| break; | |
| case 13: /* L after L+ON+EN/AN/ON */ | |
| level=pLevState->runLevel; | |
| for(k=start0-1; k>=pLevState->startON; k--) { | |
| if(levels[k]==level+3) { | |
| while(levels[k]==level+3) { | |
| levels[k--]-=2; | |
| } | |
| while(levels[k]==level) { | |
| k--; | |
| } | |
| } | |
| if(levels[k]==level+2) { | |
| levels[k]=level; | |
| continue; | |
| } | |
| levels[k]=level+1; | |
| } | |
| break; | |
| case 14: /* R after L+ON+EN/AN/ON */ | |
| level=pLevState->runLevel+1; | |
| for(k=start0-1; k>=pLevState->startON; k--) { | |
| if(levels[k]>level) { | |
| levels[k]-=2; | |
| } | |
| } | |
| break; | |
| default: /* we should never get here */ | |
| UPRV_UNREACHABLE; | |
| } | |
| } | |
| if((addLevel) || (start < start0)) { | |
| level=pLevState->runLevel + addLevel; | |
| if(start>=pLevState->runStart) { | |
| for(k=start; k<limit; k++) { | |
| levels[k]=level; | |
| } | |
| } else { | |
| setLevelsOutsideIsolates(pBiDi, start, limit, level); | |
| } | |
| } | |
| } | |
| /** | |
| * Returns the directionality of the last strong character at the end of the prologue, if any. | |
| * Requires prologue!=null. | |
| */ | |
| static DirProp | |
| lastL_R_AL(UBiDi *pBiDi) { | |
| const UChar *text=pBiDi->prologue; | |
| int32_t length=pBiDi->proLength; | |
| int32_t i; | |
| UChar32 uchar; | |
| DirProp dirProp; | |
| for(i=length; i>0; ) { | |
| /* i is decremented by U16_PREV */ | |
| U16_PREV(text, 0, i, uchar); | |
| dirProp=(DirProp)ubidi_getCustomizedClass(pBiDi, uchar); | |
| if(dirProp==L) { | |
| return DirProp_L; | |
| } | |
| if(dirProp==R || dirProp==AL) { | |
| return DirProp_R; | |
| } | |
| if(dirProp==B) { | |
| return DirProp_ON; | |
| } | |
| } | |
| return DirProp_ON; | |
| } | |
| /** | |
| * Returns the directionality of the first strong character, or digit, in the epilogue, if any. | |
| * Requires epilogue!=null. | |
| */ | |
| static DirProp | |
| firstL_R_AL_EN_AN(UBiDi *pBiDi) { | |
| const UChar *text=pBiDi->epilogue; | |
| int32_t length=pBiDi->epiLength; | |
| int32_t i; | |
| UChar32 uchar; | |
| DirProp dirProp; | |
| for(i=0; i<length; ) { | |
| /* i is incremented by U16_NEXT */ | |
| U16_NEXT(text, i, length, uchar); | |
| dirProp=(DirProp)ubidi_getCustomizedClass(pBiDi, uchar); | |
| if(dirProp==L) { | |
| return DirProp_L; | |
| } | |
| if(dirProp==R || dirProp==AL) { | |
| return DirProp_R; | |
| } | |
| if(dirProp==EN) { | |
| return DirProp_EN; | |
| } | |
| if(dirProp==AN) { | |
| return DirProp_AN; | |
| } | |
| } | |
| return DirProp_ON; | |
| } | |
| static void | |
| resolveImplicitLevels(UBiDi *pBiDi, | |
| int32_t start, int32_t limit, | |
| DirProp sor, DirProp eor) { | |
| const DirProp *dirProps=pBiDi->dirProps; | |
| DirProp dirProp; | |
| LevState levState; | |
| int32_t i, start1, start2; | |
| uint16_t oldStateImp, stateImp, actionImp; | |
| uint8_t gprop, resProp, cell; | |
| UBool inverseRTL; | |
| DirProp nextStrongProp=R; | |
| int32_t nextStrongPos=-1; | |
| /* check for RTL inverse BiDi mode */ | |
| /* FOOD FOR THOUGHT: in case of RTL inverse BiDi, it would make sense to | |
| * loop on the text characters from end to start. | |
| * This would need a different properties state table (at least different | |
| * actions) and different levels state tables (maybe very similar to the | |
| * LTR corresponding ones. | |
| */ | |
| inverseRTL=(UBool) | |
| ((start<pBiDi->lastArabicPos) && (GET_PARALEVEL(pBiDi, start) & 1) && | |
| (pBiDi->reorderingMode==UBIDI_REORDER_INVERSE_LIKE_DIRECT || | |
| pBiDi->reorderingMode==UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL)); | |
| /* initialize for property and levels state tables */ | |
| levState.startL2EN=-1; /* used for INVERSE_LIKE_DIRECT_WITH_MARKS */ | |
| levState.lastStrongRTL=-1; /* used for INVERSE_LIKE_DIRECT_WITH_MARKS */ | |
| levState.runStart=start; | |
| levState.runLevel=pBiDi->levels[start]; | |
| levState.pImpTab=(const ImpTab*)((pBiDi->pImpTabPair)->pImpTab)[levState.runLevel&1]; | |
| levState.pImpAct=(const ImpAct*)((pBiDi->pImpTabPair)->pImpAct)[levState.runLevel&1]; | |
| if(start==0 && pBiDi->proLength>0) { | |
| DirProp lastStrong=lastL_R_AL(pBiDi); | |
| if(lastStrong!=DirProp_ON) { | |
| sor=lastStrong; | |
| } | |
| } | |
| /* The isolates[] entries contain enough information to | |
| resume the bidi algorithm in the same state as it was | |
| when it was interrupted by an isolate sequence. */ | |
| if(dirProps[start]==PDI && pBiDi->isolateCount >= 0) { | |
| levState.startON=pBiDi->isolates[pBiDi->isolateCount].startON; | |
| start1=pBiDi->isolates[pBiDi->isolateCount].start1; | |
| stateImp=pBiDi->isolates[pBiDi->isolateCount].stateImp; | |
| levState.state=pBiDi->isolates[pBiDi->isolateCount].state; | |
| pBiDi->isolateCount--; | |
| } else { | |
| levState.startON=-1; | |
| start1=start; | |
| if(dirProps[start]==NSM) | |
| stateImp = 1 + sor; | |
| else | |
| stateImp=0; | |
| levState.state=0; | |
| processPropertySeq(pBiDi, &levState, sor, start, start); | |
| } | |
| start2=start; /* to make Java compiler happy */ | |
| for(i=start; i<=limit; i++) { | |
| if(i>=limit) { | |
| int32_t k; | |
| for(k=limit-1; k>start&&(DIRPROP_FLAG(dirProps[k])&MASK_BN_EXPLICIT); k--); | |
| dirProp=dirProps[k]; | |
| if(dirProp==LRI || dirProp==RLI) | |
| break; /* no forced closing for sequence ending with LRI/RLI */ | |
| gprop=eor; | |
| } else { | |
| DirProp prop, prop1; | |
| prop=dirProps[i]; | |
| if(prop==B) { | |
| pBiDi->isolateCount=-1; /* current isolates stack entry == none */ | |
| } | |
| if(inverseRTL) { | |
| if(prop==AL) { | |
| /* AL before EN does not make it AN */ | |
| prop=R; | |
| } else if(prop==EN) { | |
| if(nextStrongPos<=i) { | |
| /* look for next strong char (L/R/AL) */ | |
| int32_t j; | |
| nextStrongProp=R; /* set default */ | |
| nextStrongPos=limit; | |
| for(j=i+1; j<limit; j++) { | |
| prop1=dirProps[j]; | |
| if(prop1==L || prop1==R || prop1==AL) { | |
| nextStrongProp=prop1; | |
| nextStrongPos=j; | |
| break; | |
| } | |
| } | |
| } | |
| if(nextStrongProp==AL) { | |
| prop=AN; | |
| } | |
| } | |
| } | |
| gprop=groupProp[prop]; | |
| } | |
| oldStateImp=stateImp; | |
| cell=impTabProps[oldStateImp][gprop]; | |
| stateImp=GET_STATEPROPS(cell); /* isolate the new state */ | |
| actionImp=GET_ACTIONPROPS(cell); /* isolate the action */ | |
| if((i==limit) && (actionImp==0)) { | |
| /* there is an unprocessed sequence if its property == eor */ | |
| actionImp=1; /* process the last sequence */ | |
| } | |
| if(actionImp) { | |
| resProp=impTabProps[oldStateImp][IMPTABPROPS_RES]; | |
| switch(actionImp) { | |
| case 1: /* process current seq1, init new seq1 */ | |
| processPropertySeq(pBiDi, &levState, resProp, start1, i); | |
| start1=i; | |
| break; | |
| case 2: /* init new seq2 */ | |
| start2=i; | |
| break; | |
| case 3: /* process seq1, process seq2, init new seq1 */ | |
| processPropertySeq(pBiDi, &levState, resProp, start1, start2); | |
| processPropertySeq(pBiDi, &levState, DirProp_ON, start2, i); | |
| start1=i; | |
| break; | |
| case 4: /* process seq1, set seq1=seq2, init new seq2 */ | |
| processPropertySeq(pBiDi, &levState, resProp, start1, start2); | |
| start1=start2; | |
| start2=i; | |
| break; | |
| default: /* we should never get here */ | |
| UPRV_UNREACHABLE; | |
| } | |
| } | |
| } | |
| /* flush possible pending sequence, e.g. ON */ | |
| if(limit==pBiDi->length && pBiDi->epiLength>0) { | |
| DirProp firstStrong=firstL_R_AL_EN_AN(pBiDi); | |
| if(firstStrong!=DirProp_ON) { | |
| eor=firstStrong; | |
| } | |
| } | |
| /* look for the last char not a BN or LRE/RLE/LRO/RLO/PDF */ | |
| for(i=limit-1; i>start&&(DIRPROP_FLAG(dirProps[i])&MASK_BN_EXPLICIT); i--); | |
| dirProp=dirProps[i]; | |
| if((dirProp==LRI || dirProp==RLI) && limit<pBiDi->length) { | |
| pBiDi->isolateCount++; | |
| pBiDi->isolates[pBiDi->isolateCount].stateImp=stateImp; | |
| pBiDi->isolates[pBiDi->isolateCount].state=levState.state; | |
| pBiDi->isolates[pBiDi->isolateCount].start1=start1; | |
| pBiDi->isolates[pBiDi->isolateCount].startON=levState.startON; | |
| } | |
| else | |
| processPropertySeq(pBiDi, &levState, eor, limit, limit); | |
| } | |
| /* perform (L1) and (X9) ---------------------------------------------------- */ | |
| /* | |
| * Reset the embedding levels for some non-graphic characters (L1). | |
| * This function also sets appropriate levels for BN, and | |
| * explicit embedding types that are supposed to have been removed | |
| * from the paragraph in (X9). | |
| */ | |
| static void | |
| adjustWSLevels(UBiDi *pBiDi) { | |
| const DirProp *dirProps=pBiDi->dirProps; | |
| UBiDiLevel *levels=pBiDi->levels; | |
| int32_t i; | |
| if(pBiDi->flags&MASK_WS) { | |
| UBool orderParagraphsLTR=pBiDi->orderParagraphsLTR; | |
| Flags flag; | |
| i=pBiDi->trailingWSStart; | |
| while(i>0) { | |
| /* reset a sequence of WS/BN before eop and B/S to the paragraph paraLevel */ | |
| while(i>0 && (flag=DIRPROP_FLAG(dirProps[--i]))&MASK_WS) { | |
| if(orderParagraphsLTR&&(flag&DIRPROP_FLAG(B))) { | |
| levels[i]=0; | |
| } else { | |
| levels[i]=GET_PARALEVEL(pBiDi, i); | |
| } | |
| } | |
| /* reset BN to the next character's paraLevel until B/S, which restarts above loop */ | |
| /* here, i+1 is guaranteed to be <length */ | |
| while(i>0) { | |
| flag=DIRPROP_FLAG(dirProps[--i]); | |
| if(flag&MASK_BN_EXPLICIT) { | |
| levels[i]=levels[i+1]; | |
| } else if(orderParagraphsLTR&&(flag&DIRPROP_FLAG(B))) { | |
| levels[i]=0; | |
| break; | |
| } else if(flag&MASK_B_S) { | |
| levels[i]=GET_PARALEVEL(pBiDi, i); | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| U_CAPI void U_EXPORT2 | |
| ubidi_setContext(UBiDi *pBiDi, | |
| const UChar *prologue, int32_t proLength, | |
| const UChar *epilogue, int32_t epiLength, | |
| UErrorCode *pErrorCode) { | |
| /* check the argument values */ | |
| RETURN_VOID_IF_NULL_OR_FAILING_ERRCODE(pErrorCode); | |
| if(pBiDi==NULL || proLength<-1 || epiLength<-1 || | |
| (prologue==NULL && proLength!=0) || (epilogue==NULL && epiLength!=0)) { | |
| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; | |
| return; | |
| } | |
| if(proLength==-1) { | |
| pBiDi->proLength=u_strlen(prologue); | |
| } else { | |
| pBiDi->proLength=proLength; | |
| } | |
| if(epiLength==-1) { | |
| pBiDi->epiLength=u_strlen(epilogue); | |
| } else { | |
| pBiDi->epiLength=epiLength; | |
| } | |
| pBiDi->prologue=prologue; | |
| pBiDi->epilogue=epilogue; | |
| } | |
| static void | |
| setParaSuccess(UBiDi *pBiDi) { | |
| pBiDi->proLength=0; /* forget the last context */ | |
| pBiDi->epiLength=0; | |
| pBiDi->pParaBiDi=pBiDi; /* mark successful setPara */ | |
| } | |
| #define BIDI_MIN(x, y) ((x)<(y) ? (x) : (y)) | |
| #define BIDI_ABS(x) ((x)>=0 ? (x) : (-(x))) | |
| static void | |
| setParaRunsOnly(UBiDi *pBiDi, const UChar *text, int32_t length, | |
| UBiDiLevel paraLevel, UErrorCode *pErrorCode) { | |
| int32_t *runsOnlyMemory = NULL; | |
| int32_t *visualMap; | |
| UChar *visualText; | |
| int32_t saveLength, saveTrailingWSStart; | |
| const UBiDiLevel *levels; | |
| UBiDiLevel *saveLevels; | |
| UBiDiDirection saveDirection; | |
| UBool saveMayAllocateText; | |
| Run *runs; | |
| int32_t visualLength, i, j, visualStart, logicalStart, | |
| runCount, runLength, addedRuns, insertRemove, | |
| start, limit, step, indexOddBit, logicalPos, | |
| index0, index1; | |
| uint32_t saveOptions; | |
| pBiDi->reorderingMode=UBIDI_REORDER_DEFAULT; | |
| if(length==0) { | |
| ubidi_setPara(pBiDi, text, length, paraLevel, NULL, pErrorCode); | |
| goto cleanup3; | |
| } | |
| /* obtain memory for mapping table and visual text */ | |
| runsOnlyMemory=static_cast<int32_t *>(uprv_malloc(length*(sizeof(int32_t)+sizeof(UChar)+sizeof(UBiDiLevel)))); | |
| if(runsOnlyMemory==NULL) { | |
| *pErrorCode=U_MEMORY_ALLOCATION_ERROR; | |
| goto cleanup3; | |
| } | |
| visualMap=runsOnlyMemory; | |
| visualText=(UChar *)&visualMap[length]; | |
| saveLevels=(UBiDiLevel *)&visualText[length]; | |
| saveOptions=pBiDi->reorderingOptions; | |
| if(saveOptions & UBIDI_OPTION_INSERT_MARKS) { | |
| pBiDi->reorderingOptions&=~UBIDI_OPTION_INSERT_MARKS; | |
| pBiDi->reorderingOptions|=UBIDI_OPTION_REMOVE_CONTROLS; | |
| } | |
| paraLevel&=1; /* accept only 0 or 1 */ | |
| ubidi_setPara(pBiDi, text, length, paraLevel, NULL, pErrorCode); | |
| if(U_FAILURE(*pErrorCode)) { | |
| goto cleanup3; | |
| } | |
| /* we cannot access directly pBiDi->levels since it is not yet set if | |
| * direction is not MIXED | |
| */ | |
| levels=ubidi_getLevels(pBiDi, pErrorCode); | |
| uprv_memcpy(saveLevels, levels, (size_t)pBiDi->length*sizeof(UBiDiLevel)); | |
| saveTrailingWSStart=pBiDi->trailingWSStart; | |
| saveLength=pBiDi->length; | |
| saveDirection=pBiDi->direction; | |
| /* FOOD FOR THOUGHT: instead of writing the visual text, we could use | |
| * the visual map and the dirProps array to drive the second call | |
| * to ubidi_setPara (but must make provision for possible removal of | |
| * BiDi controls. Alternatively, only use the dirProps array via | |
| * customized classifier callback. | |
| */ | |
| visualLength=ubidi_writeReordered(pBiDi, visualText, length, | |
| UBIDI_DO_MIRRORING, pErrorCode); | |
| ubidi_getVisualMap(pBiDi, visualMap, pErrorCode); | |
| if(U_FAILURE(*pErrorCode)) { | |
| goto cleanup2; | |
| } | |
| pBiDi->reorderingOptions=saveOptions; | |
| pBiDi->reorderingMode=UBIDI_REORDER_INVERSE_LIKE_DIRECT; | |
| paraLevel^=1; | |
| /* Because what we did with reorderingOptions, visualText may be shorter | |
| * than the original text. But we don't want the levels memory to be | |
| * reallocated shorter than the original length, since we need to restore | |
| * the levels as after the first call to ubidi_setpara() before returning. | |
| * We will force mayAllocateText to FALSE before the second call to | |
| * ubidi_setpara(), and will restore it afterwards. | |
| */ | |
| saveMayAllocateText=pBiDi->mayAllocateText; | |
| pBiDi->mayAllocateText=FALSE; | |
| ubidi_setPara(pBiDi, visualText, visualLength, paraLevel, NULL, pErrorCode); | |
| pBiDi->mayAllocateText=saveMayAllocateText; | |
| ubidi_getRuns(pBiDi, pErrorCode); | |
| if(U_FAILURE(*pErrorCode)) { | |
| goto cleanup1; | |
| } | |
| /* check if some runs must be split, count how many splits */ | |
| addedRuns=0; | |
| runCount=pBiDi->runCount; | |
| runs=pBiDi->runs; | |
| visualStart=0; | |
| for(i=0; i<runCount; i++, visualStart+=runLength) { | |
| runLength=runs[i].visualLimit-visualStart; | |
| if(runLength<2) { | |
| continue; | |
| } | |
| logicalStart=GET_INDEX(runs[i].logicalStart); | |
| for(j=logicalStart+1; j<logicalStart+runLength; j++) { | |
| index0=visualMap[j]; | |
| index1=visualMap[j-1]; | |
| if((BIDI_ABS(index0-index1)!=1) || (saveLevels[index0]!=saveLevels[index1])) { | |
| addedRuns++; | |
| } | |
| } | |
| } | |
| if(addedRuns) { | |
| if(getRunsMemory(pBiDi, runCount+addedRuns)) { | |
| if(runCount==1) { | |
| /* because we switch from UBiDi.simpleRuns to UBiDi.runs */ | |
| pBiDi->runsMemory[0]=runs[0]; | |
| } | |
| runs=pBiDi->runs=pBiDi->runsMemory; | |
| pBiDi->runCount+=addedRuns; | |
| } else { | |
| goto cleanup1; | |
| } | |
| } | |
| /* split runs which are not consecutive in source text */ | |
| for(i=runCount-1; i>=0; i--) { | |
| runLength= i==0 ? runs[0].visualLimit : | |
| runs[i].visualLimit-runs[i-1].visualLimit; | |
| logicalStart=runs[i].logicalStart; | |
| indexOddBit=GET_ODD_BIT(logicalStart); | |
| logicalStart=GET_INDEX(logicalStart); | |
| if(runLength<2) { | |
| if(addedRuns) { | |
| runs[i+addedRuns]=runs[i]; | |
| } | |
| logicalPos=visualMap[logicalStart]; | |
| runs[i+addedRuns].logicalStart=MAKE_INDEX_ODD_PAIR(logicalPos, | |
| saveLevels[logicalPos]^indexOddBit); | |
| continue; | |
| } | |
| if(indexOddBit) { | |
| start=logicalStart; | |
| limit=logicalStart+runLength-1; | |
| step=1; | |
| } else { | |
| start=logicalStart+runLength-1; | |
| limit=logicalStart; | |
| step=-1; | |
| } | |
| for(j=start; j!=limit; j+=step) { | |
| index0=visualMap[j]; | |
| index1=visualMap[j+step]; | |
| if((BIDI_ABS(index0-index1)!=1) || (saveLevels[index0]!=saveLevels[index1])) { | |
| logicalPos=BIDI_MIN(visualMap[start], index0); | |
| runs[i+addedRuns].logicalStart=MAKE_INDEX_ODD_PAIR(logicalPos, | |
| saveLevels[logicalPos]^indexOddBit); | |
| runs[i+addedRuns].visualLimit=runs[i].visualLimit; | |
| runs[i].visualLimit-=BIDI_ABS(j-start)+1; | |
| insertRemove=runs[i].insertRemove&(LRM_AFTER|RLM_AFTER); | |
| runs[i+addedRuns].insertRemove=insertRemove; | |
| runs[i].insertRemove&=~insertRemove; | |
| start=j+step; | |
| addedRuns--; | |
| } | |
| } | |
| if(addedRuns) { | |
| runs[i+addedRuns]=runs[i]; | |
| } | |
| logicalPos=BIDI_MIN(visualMap[start], visualMap[limit]); | |
| runs[i+addedRuns].logicalStart=MAKE_INDEX_ODD_PAIR(logicalPos, | |
| saveLevels[logicalPos]^indexOddBit); | |
| } | |
| cleanup1: | |
| /* restore initial paraLevel */ | |
| pBiDi->paraLevel^=1; | |
| cleanup2: | |
| /* restore real text */ | |
| pBiDi->text=text; | |
| pBiDi->length=saveLength; | |
| pBiDi->originalLength=length; | |
| pBiDi->direction=saveDirection; | |
| /* the saved levels should never excess levelsSize, but we check anyway */ | |
| if(saveLength>pBiDi->levelsSize) { | |
| saveLength=pBiDi->levelsSize; | |
| } | |
| uprv_memcpy(pBiDi->levels, saveLevels, (size_t)saveLength*sizeof(UBiDiLevel)); | |
| pBiDi->trailingWSStart=saveTrailingWSStart; | |
| if(pBiDi->runCount>1) { | |
| pBiDi->direction=UBIDI_MIXED; | |
| } | |
| cleanup3: | |
| /* free memory for mapping table and visual text */ | |
| uprv_free(runsOnlyMemory); | |
| pBiDi->reorderingMode=UBIDI_REORDER_RUNS_ONLY; | |
| } | |
| /* ubidi_setPara ------------------------------------------------------------ */ | |
| U_CAPI void U_EXPORT2 | |
| ubidi_setPara(UBiDi *pBiDi, const UChar *text, int32_t length, | |
| UBiDiLevel paraLevel, UBiDiLevel *embeddingLevels, | |
| UErrorCode *pErrorCode) { | |
| UBiDiDirection direction; | |
| DirProp *dirProps; | |
| /* check the argument values */ | |
| RETURN_VOID_IF_NULL_OR_FAILING_ERRCODE(pErrorCode); | |
| if(pBiDi==NULL || text==NULL || length<-1 || | |
| (paraLevel>UBIDI_MAX_EXPLICIT_LEVEL && paraLevel<UBIDI_DEFAULT_LTR)) { | |
| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; | |
| return; | |
| } | |
| if(length==-1) { | |
| length=u_strlen(text); | |
| } | |
| /* special treatment for RUNS_ONLY mode */ | |
| if(pBiDi->reorderingMode==UBIDI_REORDER_RUNS_ONLY) { | |
| setParaRunsOnly(pBiDi, text, length, paraLevel, pErrorCode); | |
| return; | |
| } | |
| /* initialize the UBiDi structure */ | |
| pBiDi->pParaBiDi=NULL; /* mark unfinished setPara */ | |
| pBiDi->text=text; | |
| pBiDi->length=pBiDi->originalLength=pBiDi->resultLength=length; | |
| pBiDi->paraLevel=paraLevel; | |
| pBiDi->direction=(UBiDiDirection)(paraLevel&1); | |
| pBiDi->paraCount=1; | |
| pBiDi->dirProps=NULL; | |
| pBiDi->levels=NULL; | |
| pBiDi->runs=NULL; | |
| pBiDi->insertPoints.size=0; /* clean up from last call */ | |
| pBiDi->insertPoints.confirmed=0; /* clean up from last call */ | |
| /* | |
| * Save the original paraLevel if contextual; otherwise, set to 0. | |
| */ | |
| pBiDi->defaultParaLevel=IS_DEFAULT_LEVEL(paraLevel); | |
| 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; | |
| pBiDi->defaultParaLevel=0; | |
| } | |
| pBiDi->flags=DIRPROP_FLAG_LR(paraLevel); | |
| pBiDi->runCount=0; | |
| pBiDi->paraCount=0; | |
| setParaSuccess(pBiDi); /* mark successful setPara */ | |
| return; | |
| } | |
| pBiDi->runCount=-1; | |
| /* allocate paras memory */ | |
| if(pBiDi->parasMemory) | |
| pBiDi->paras=pBiDi->parasMemory; | |
| else | |
| pBiDi->paras=pBiDi->simpleParas; | |
| /* | |
| * Get the directional properties, | |
| * the flags bit-set, and | |
| * determine the paragraph level if necessary. | |
| */ | |
| if(getDirPropsMemory(pBiDi, length)) { | |
| pBiDi->dirProps=pBiDi->dirPropsMemory; | |
| if(!getDirProps(pBiDi)) { | |
| *pErrorCode=U_MEMORY_ALLOCATION_ERROR; | |
| return; | |
| } | |
| } else { | |
| *pErrorCode=U_MEMORY_ALLOCATION_ERROR; | |
| return; | |
| } | |
| dirProps=pBiDi->dirProps; | |
| /* the processed length may have changed if UBIDI_OPTION_STREAMING */ | |
| length= pBiDi->length; | |
| pBiDi->trailingWSStart=length; /* the levels[] will reflect the WS run */ | |
| /* are explicit levels specified? */ | |
| if(embeddingLevels==NULL) { | |
| /* no: determine explicit levels according to the (Xn) rules */\ | |
| if(getLevelsMemory(pBiDi, length)) { | |
| pBiDi->levels=pBiDi->levelsMemory; | |
| direction=resolveExplicitLevels(pBiDi, pErrorCode); | |
| if(U_FAILURE(*pErrorCode)) { | |
| return; | |
| } | |
| } else { | |
| *pErrorCode=U_MEMORY_ALLOCATION_ERROR; | |
| return; | |
| } | |
| } else { | |
| /* set BN for all explicit codes, check that all levels are 0 or paraLevel..UBIDI_MAX_EXPLICIT_LEVEL */ | |
| pBiDi->levels=embeddingLevels; | |
| direction=checkExplicitLevels(pBiDi, pErrorCode); | |
| if(U_FAILURE(*pErrorCode)) { | |
| return; | |
| } | |
| } | |
| /* allocate isolate memory */ | |
| if(pBiDi->isolateCount<=SIMPLE_ISOLATES_COUNT) | |
| pBiDi->isolates=pBiDi->simpleIsolates; | |
| else | |
| if((int32_t)(pBiDi->isolateCount*sizeof(Isolate))<=pBiDi->isolatesSize) | |
| pBiDi->isolates=pBiDi->isolatesMemory; | |
| else { | |
| if(getInitialIsolatesMemory(pBiDi, pBiDi->isolateCount)) { | |
| pBiDi->isolates=pBiDi->isolatesMemory; | |
| } else { | |
| *pErrorCode=U_MEMORY_ALLOCATION_ERROR; | |
| return; | |
| } | |
| } | |
| pBiDi->isolateCount=-1; /* current isolates stack entry == none */ | |
| /* | |
| * 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: | |
| /* all levels are implicitly at paraLevel (important for ubidi_getLevels()) */ | |
| pBiDi->trailingWSStart=0; | |
| break; | |
| case UBIDI_RTL: | |
| /* all levels are implicitly at paraLevel (important for ubidi_getLevels()) */ | |
| pBiDi->trailingWSStart=0; | |
| break; | |
| default: | |
| /* | |
| * Choose the right implicit state table | |
| */ | |
| switch(pBiDi->reorderingMode) { | |
| case UBIDI_REORDER_DEFAULT: | |
| pBiDi->pImpTabPair=&impTab_DEFAULT; | |
| break; | |
| case UBIDI_REORDER_NUMBERS_SPECIAL: | |
| pBiDi->pImpTabPair=&impTab_NUMBERS_SPECIAL; | |
| break; | |
| case UBIDI_REORDER_GROUP_NUMBERS_WITH_R: | |
| pBiDi->pImpTabPair=&impTab_GROUP_NUMBERS_WITH_R; | |
| break; | |
| case UBIDI_REORDER_INVERSE_NUMBERS_AS_L: | |
| pBiDi->pImpTabPair=&impTab_INVERSE_NUMBERS_AS_L; | |
| break; | |
| case UBIDI_REORDER_INVERSE_LIKE_DIRECT: | |
| if (pBiDi->reorderingOptions & UBIDI_OPTION_INSERT_MARKS) { | |
| pBiDi->pImpTabPair=&impTab_INVERSE_LIKE_DIRECT_WITH_MARKS; | |
| } else { | |
| pBiDi->pImpTabPair=&impTab_INVERSE_LIKE_DIRECT; | |
| } | |
| break; | |
| case UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL: | |
| if (pBiDi->reorderingOptions & UBIDI_OPTION_INSERT_MARKS) { | |
| pBiDi->pImpTabPair=&impTab_INVERSE_FOR_NUMBERS_SPECIAL_WITH_MARKS; | |
| } else { | |
| pBiDi->pImpTabPair=&impTab_INVERSE_FOR_NUMBERS_SPECIAL; | |
| } | |
| break; | |
| default: | |
| /* we should never get here */ | |
| UPRV_UNREACHABLE; | |
| } | |
| /* | |
| * 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->paraCount<=1 && | |
| !(pBiDi->flags&DIRPROP_FLAG_MULTI_RUNS)) { | |
| resolveImplicitLevels(pBiDi, 0, length, | |
| GET_LR_FROM_LEVEL(GET_PARALEVEL(pBiDi, 0)), | |
| GET_LR_FROM_LEVEL(GET_PARALEVEL(pBiDi, length-1))); | |
| } 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=GET_PARALEVEL(pBiDi, 0); | |
| 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 */ | |
| start=limit; | |
| level=nextLevel; | |
| if((start>0) && (dirProps[start-1]==B)) { | |
| /* except if this is a new paragraph, then set sor = para level */ | |
| sor=GET_LR_FROM_LEVEL(GET_PARALEVEL(pBiDi, start)); | |
| } else { | |
| sor=eor; | |
| } | |
| /* search for the limit of this run */ | |
| while((++limit<length) && | |
| ((levels[limit]==level) || | |
| (DIRPROP_FLAG(dirProps[limit])&MASK_BN_EXPLICIT))) {} | |
| /* get the correct level of the next run */ | |
| if(limit<length) { | |
| nextLevel=levels[limit]; | |
| } else { | |
| nextLevel=GET_PARALEVEL(pBiDi, length-1); | |
| } | |
| /* determine eor from max(level, nextLevel); sor is last run's eor */ | |
| if(NO_OVERRIDE(level)<NO_OVERRIDE(nextLevel)) { | |
| 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); | |
| } | |
| /* check if we got any memory shortage while adding insert points */ | |
| if (U_FAILURE(pBiDi->insertPoints.errorCode)) | |
| { | |
| *pErrorCode=pBiDi->insertPoints.errorCode; | |
| return; | |
| } | |
| /* reset the embedding levels for some non-graphic characters (L1), (X9) */ | |
| adjustWSLevels(pBiDi); | |
| break; | |
| } | |
| /* add RLM for inverse Bidi with contextual orientation resolving | |
| * to RTL which would not round-trip otherwise | |
| */ | |
| if((pBiDi->defaultParaLevel>0) && | |
| (pBiDi->reorderingOptions & UBIDI_OPTION_INSERT_MARKS) && | |
| ((pBiDi->reorderingMode==UBIDI_REORDER_INVERSE_LIKE_DIRECT) || | |
| (pBiDi->reorderingMode==UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL))) { | |
| int32_t i, j, start, last; | |
| UBiDiLevel level; | |
| DirProp dirProp; | |
| for(i=0; i<pBiDi->paraCount; i++) { | |
| last=(pBiDi->paras[i].limit)-1; | |
| level= static_cast<UBiDiLevel>(pBiDi->paras[i].level); | |
| if(level==0) | |
| continue; /* LTR paragraph */ | |
| start= i==0 ? 0 : pBiDi->paras[i-1].limit; | |
| for(j=last; j>=start; j--) { | |
| dirProp=dirProps[j]; | |
| if(dirProp==L) { | |
| if(j<last) { | |
| while(dirProps[last]==B) { | |
| last--; | |
| } | |
| } | |
| addPoint(pBiDi, last, RLM_BEFORE); | |
| break; | |
| } | |
| if(DIRPROP_FLAG(dirProp) & MASK_R_AL) { | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| if(pBiDi->reorderingOptions & UBIDI_OPTION_REMOVE_CONTROLS) { | |
| pBiDi->resultLength -= pBiDi->controlCount; | |
| } else { | |
| pBiDi->resultLength += pBiDi->insertPoints.size; | |
| } | |
| setParaSuccess(pBiDi); /* mark successful setPara */ | |
| } | |
| U_CAPI void U_EXPORT2 | |
| ubidi_orderParagraphsLTR(UBiDi *pBiDi, UBool orderParagraphsLTR) { | |
| if(pBiDi!=NULL) { | |
| pBiDi->orderParagraphsLTR=orderParagraphsLTR; | |
| } | |
| } | |
| U_CAPI UBool U_EXPORT2 | |
| ubidi_isOrderParagraphsLTR(UBiDi *pBiDi) { | |
| if(pBiDi!=NULL) { | |
| return pBiDi->orderParagraphsLTR; | |
| } else { | |
| return FALSE; | |
| } | |
| } | |
| U_CAPI UBiDiDirection U_EXPORT2 | |
| ubidi_getDirection(const UBiDi *pBiDi) { | |
| if(IS_VALID_PARA_OR_LINE(pBiDi)) { | |
| return pBiDi->direction; | |
| } else { | |
| return UBIDI_LTR; | |
| } | |
| } | |
| U_CAPI const UChar * U_EXPORT2 | |
| ubidi_getText(const UBiDi *pBiDi) { | |
| if(IS_VALID_PARA_OR_LINE(pBiDi)) { | |
| return pBiDi->text; | |
| } else { | |
| return NULL; | |
| } | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| ubidi_getLength(const UBiDi *pBiDi) { | |
| if(IS_VALID_PARA_OR_LINE(pBiDi)) { | |
| return pBiDi->originalLength; | |
| } else { | |
| return 0; | |
| } | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| ubidi_getProcessedLength(const UBiDi *pBiDi) { | |
| if(IS_VALID_PARA_OR_LINE(pBiDi)) { | |
| return pBiDi->length; | |
| } else { | |
| return 0; | |
| } | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| ubidi_getResultLength(const UBiDi *pBiDi) { | |
| if(IS_VALID_PARA_OR_LINE(pBiDi)) { | |
| return pBiDi->resultLength; | |
| } else { | |
| return 0; | |
| } | |
| } | |
| /* paragraphs API functions ------------------------------------------------- */ | |
| U_CAPI UBiDiLevel U_EXPORT2 | |
| ubidi_getParaLevel(const UBiDi *pBiDi) { | |
| if(IS_VALID_PARA_OR_LINE(pBiDi)) { | |
| return pBiDi->paraLevel; | |
| } else { | |
| return 0; | |
| } | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| ubidi_countParagraphs(UBiDi *pBiDi) { | |
| if(!IS_VALID_PARA_OR_LINE(pBiDi)) { | |
| return 0; | |
| } else { | |
| return pBiDi->paraCount; | |
| } | |
| } | |
| U_CAPI void U_EXPORT2 | |
| ubidi_getParagraphByIndex(const UBiDi *pBiDi, int32_t paraIndex, | |
| int32_t *pParaStart, int32_t *pParaLimit, | |
| UBiDiLevel *pParaLevel, UErrorCode *pErrorCode) { | |
| int32_t paraStart; | |
| /* check the argument values */ | |
| RETURN_VOID_IF_NULL_OR_FAILING_ERRCODE(pErrorCode); | |
| RETURN_VOID_IF_NOT_VALID_PARA_OR_LINE(pBiDi, *pErrorCode); | |
| RETURN_VOID_IF_BAD_RANGE(paraIndex, 0, pBiDi->paraCount, *pErrorCode); | |
| pBiDi=pBiDi->pParaBiDi; /* get Para object if Line object */ | |
| if(paraIndex) { | |
| paraStart=pBiDi->paras[paraIndex-1].limit; | |
| } else { | |
| paraStart=0; | |
| } | |
| if(pParaStart!=NULL) { | |
| *pParaStart=paraStart; | |
| } | |
| if(pParaLimit!=NULL) { | |
| *pParaLimit=pBiDi->paras[paraIndex].limit; | |
| } | |
| if(pParaLevel!=NULL) { | |
| *pParaLevel=GET_PARALEVEL(pBiDi, paraStart); | |
| } | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| ubidi_getParagraph(const UBiDi *pBiDi, int32_t charIndex, | |
| int32_t *pParaStart, int32_t *pParaLimit, | |
| UBiDiLevel *pParaLevel, UErrorCode *pErrorCode) { | |
| int32_t paraIndex; | |
| /* check the argument values */ | |
| /* pErrorCode will be checked by the call to ubidi_getParagraphByIndex */ | |
| RETURN_IF_NULL_OR_FAILING_ERRCODE(pErrorCode, -1); | |
| RETURN_IF_NOT_VALID_PARA_OR_LINE(pBiDi, *pErrorCode, -1); | |
| pBiDi=pBiDi->pParaBiDi; /* get Para object if Line object */ | |
| RETURN_IF_BAD_RANGE(charIndex, 0, pBiDi->length, *pErrorCode, -1); | |
| for(paraIndex=0; charIndex>=pBiDi->paras[paraIndex].limit; paraIndex++); | |
| ubidi_getParagraphByIndex(pBiDi, paraIndex, pParaStart, pParaLimit, pParaLevel, pErrorCode); | |
| return paraIndex; | |
| } | |
| U_CAPI void U_EXPORT2 | |
| ubidi_setClassCallback(UBiDi *pBiDi, UBiDiClassCallback *newFn, | |
| const void *newContext, UBiDiClassCallback **oldFn, | |
| const void **oldContext, UErrorCode *pErrorCode) | |
| { | |
| RETURN_VOID_IF_NULL_OR_FAILING_ERRCODE(pErrorCode); | |
| if(pBiDi==NULL) { | |
| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; | |
| return; | |
| } | |
| if( oldFn ) | |
| { | |
| *oldFn = pBiDi->fnClassCallback; | |
| } | |
| if( oldContext ) | |
| { | |
| *oldContext = pBiDi->coClassCallback; | |
| } | |
| pBiDi->fnClassCallback = newFn; | |
| pBiDi->coClassCallback = newContext; | |
| } | |
| U_CAPI void U_EXPORT2 | |
| ubidi_getClassCallback(UBiDi *pBiDi, UBiDiClassCallback **fn, const void **context) | |
| { | |
| if(pBiDi==NULL) { | |
| return; | |
| } | |
| if( fn ) | |
| { | |
| *fn = pBiDi->fnClassCallback; | |
| } | |
| if( context ) | |
| { | |
| *context = pBiDi->coClassCallback; | |
| } | |
| } | |
| U_CAPI UCharDirection U_EXPORT2 | |
| ubidi_getCustomizedClass(UBiDi *pBiDi, UChar32 c) | |
| { | |
| UCharDirection dir; | |
| if( pBiDi->fnClassCallback == NULL || | |
| (dir = (*pBiDi->fnClassCallback)(pBiDi->coClassCallback, c)) == U_BIDI_CLASS_DEFAULT ) | |
| { | |
| dir = ubidi_getClass(c); | |
| } | |
| if(dir >= U_CHAR_DIRECTION_COUNT) { | |
| dir = (UCharDirection)ON; | |
| } | |
| return dir; | |
| } |