diff -r 000000000000 -r 1fb32624e06b fontservices/textshaperplugin/IcuSource/common/ubidiimp.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/fontservices/textshaperplugin/IcuSource/common/ubidiimp.h Tue Feb 02 02:02:46 2010 +0200 @@ -0,0 +1,265 @@ +/* +****************************************************************************** +* +* Copyright (C) 1999-2005, International Business Machines +* Corporation and others. All Rights Reserved. +* +****************************************************************************** +* file name: ubidiimp.h +* encoding: US-ASCII +* tab size: 8 (not used) +* indentation:4 +* +* created on: 1999aug06 +* created by: Markus W. Scherer +*/ + +#ifndef UBIDIIMP_H +#define UBIDIIMP_H + +/* set import/export definitions */ +#ifdef U_COMMON_IMPLEMENTATION + +#include "unicode/utypes.h" +#include "unicode/uchar.h" +#include "ubidi_props.h" + +/* miscellaneous definitions ---------------------------------------------- */ + +typedef uint8_t DirProp; +typedef uint32_t Flags; + +/* Comparing the description of the BiDi algorithm with this implementation + is easier with the same names for the BiDi types in the code as there. + See UCharDirection in uchar.h . +*/ +enum { + L= U_LEFT_TO_RIGHT, + R= U_RIGHT_TO_LEFT, + EN= U_EUROPEAN_NUMBER, + ES= U_EUROPEAN_NUMBER_SEPARATOR, + ET= U_EUROPEAN_NUMBER_TERMINATOR, + AN= U_ARABIC_NUMBER, + CS= U_COMMON_NUMBER_SEPARATOR, + B= U_BLOCK_SEPARATOR, + S= U_SEGMENT_SEPARATOR, + WS= U_WHITE_SPACE_NEUTRAL, + ON= U_OTHER_NEUTRAL, + LRE=U_LEFT_TO_RIGHT_EMBEDDING, + LRO=U_LEFT_TO_RIGHT_OVERRIDE, + AL= U_RIGHT_TO_LEFT_ARABIC, + RLE=U_RIGHT_TO_LEFT_EMBEDDING, + RLO=U_RIGHT_TO_LEFT_OVERRIDE, + PDF=U_POP_DIRECTIONAL_FORMAT, + NSM=U_DIR_NON_SPACING_MARK, + BN= U_BOUNDARY_NEUTRAL, + dirPropCount +}; + +/* + * Sometimes, bit values are more appropriate + * to deal with directionality properties. + * Abbreviations in these macro names refer to names + * used in the BiDi algorithm. + */ +#define DIRPROP_FLAG(dir) (1UL<<(dir)) + +/* special flag for multiple runs from explicit embedding codes */ +#define DIRPROP_FLAG_MULTI_RUNS (1UL<<31) + +/* are there any characters that are LTR or RTL? */ +#define MASK_LTR (DIRPROP_FLAG(L)|DIRPROP_FLAG(EN)|DIRPROP_FLAG(AN)|DIRPROP_FLAG(LRE)|DIRPROP_FLAG(LRO)) +#define MASK_RTL (DIRPROP_FLAG(R)|DIRPROP_FLAG(AL)|DIRPROP_FLAG(RLE)|DIRPROP_FLAG(RLO)) + +/* explicit embedding codes */ +#define MASK_LRX (DIRPROP_FLAG(LRE)|DIRPROP_FLAG(LRO)) +#define MASK_RLX (DIRPROP_FLAG(RLE)|DIRPROP_FLAG(RLO)) +#define MASK_OVERRIDE (DIRPROP_FLAG(LRO)|DIRPROP_FLAG(RLO)) + +#define MASK_EXPLICIT (MASK_LRX|MASK_RLX|DIRPROP_FLAG(PDF)) +#define MASK_BN_EXPLICIT (DIRPROP_FLAG(BN)|MASK_EXPLICIT) + +/* paragraph and segment separators */ +#define MASK_B_S (DIRPROP_FLAG(B)|DIRPROP_FLAG(S)) + +/* all types that are counted as White Space or Neutral in some steps */ +#define MASK_WS (MASK_B_S|DIRPROP_FLAG(WS)|MASK_BN_EXPLICIT) +#define MASK_N (DIRPROP_FLAG(ON)|MASK_WS) + +/* all types that are included in a sequence of European Terminators for (W5) */ +#define MASK_ET_NSM_BN (DIRPROP_FLAG(ET)|DIRPROP_FLAG(NSM)|MASK_BN_EXPLICIT) + +/* types that are neutrals or could becomes neutrals in (Wn) */ +#define MASK_POSSIBLE_N (DIRPROP_FLAG(CS)|DIRPROP_FLAG(ES)|DIRPROP_FLAG(ET)|MASK_N) + +/* + * These types may be changed to "e", + * the embedding type (L or R) of the run, + * in the BiDi algorithm (N2) + */ +#define MASK_EMBEDDING (DIRPROP_FLAG(NSM)|MASK_POSSIBLE_N) + +/* the dirProp's L and R are defined to 0 and 1 values in UCharDirection */ +#define GET_LR_FROM_LEVEL(level) ((DirProp)((level)&1)) + +#define IS_DEFAULT_LEVEL(level) ((level)>=0xfe) + +/* + * The following bit is ORed to the property of characters in paragraphs + * with contextual RTL direction when paraLevel is contextual. + */ +#define CONTEXT_RTL 0x80 +#define NO_CONTEXT_RTL(dir) ((dir)&~CONTEXT_RTL) +/* + * The following is a variant of DIRPROP_FLAG which ignores the CONTEXT_RTL bit. + */ +#define DIRPROP_FLAG_NC(dir) (1UL<<(NO_CONTEXT_RTL(dir))) + +#define GET_PARALEVEL(ubidi, index) \ + (UBiDiLevel)((ubidi)->defaultParaLevel ? (ubidi)->dirProps[index]>>7 \ + : (ubidi)->paraLevel) + +/* Paragraph type for multiple paragraph support --- -------------------- */ +typedef int32_t Para; + +#define CR 0x000D +#define LF 0x000A + +/* Run structure for reordering --------------------------------------------- */ + +typedef struct Run { + int32_t logicalStart, /* first character of the run; b31 indicates even/odd level */ + visualLimit; /* last visual position of the run +1 */ +} Run; + +/* in a Run, logicalStart will get this bit set if the run level is odd */ +#define INDEX_ODD_BIT (1UL<<31) + +#define MAKE_INDEX_ODD_PAIR(index, level) (index|((int32_t)level<<31)) +#define ADD_ODD_BIT_FROM_LEVEL(x, level) ((x)|=((int32_t)level<<31)) +#define REMOVE_ODD_BIT(x) ((x)&=~INDEX_ODD_BIT) + +#define GET_INDEX(x) (x&~INDEX_ODD_BIT) +#define GET_ODD_BIT(x) ((uint32_t)x>>31) +#define IS_ODD_RUN(x) ((x&INDEX_ODD_BIT)!=0) +#define IS_EVEN_RUN(x) ((x&INDEX_ODD_BIT)==0) + +U_CFUNC UBool +ubidi_getRuns(UBiDi *pBiDi); + +/* UBiDi structure ----------------------------------------------------------- */ + +struct UBiDi { + /* pointer to parent paragraph object (pointer to self if this object is + * a paragraph object); set to NULL in a newly opened object; set to a + * real value after a successful execution of ubidi_setPara or ubidi_setLine + */ + const UBiDi * pParaBiDi; + + const UBiDiProps *bdp; + + /* alias pointer to the current text */ + const UChar *text; + + /* length of the current text */ + int32_t length; + + /* memory sizes in bytes */ + int32_t dirPropsSize, levelsSize, parasSize, runsSize; + + /* allocated memory */ + DirProp *dirPropsMemory; + UBiDiLevel *levelsMemory; + Para *parasMemory; + Run *runsMemory; + + /* indicators for whether memory may be allocated after ubidi_open() */ + UBool mayAllocateText, mayAllocateRuns; + + /* arrays with one value per text-character */ + const DirProp *dirProps; + UBiDiLevel *levels; + + /* are we performing an approximation of the "inverse BiDi" algorithm? */ + UBool isInverse; + UBool isInverse2; + + /* must block separators receive level 0? */ + UBool orderParagraphsLTR; + + /* the paragraph level */ + UBiDiLevel paraLevel; + /* original paraLevel when contextual */ + /* must be one of UBIDI_DEFAULT_xxx or 0 if not contextual */ + UBiDiLevel defaultParaLevel; + + /* the following is set in ubidi_setPara, used in processPropertySeq */ + const struct ImpTabPair * pImpTabPair; /* pointer to levels state table pair */ + + /* the overall paragraph or line directionality - see UBiDiDirection */ + UBiDiDirection direction; + + /* flags is a bit set for which directional properties are in the text */ + Flags flags; + + /* characters after trailingWSStart are WS and are */ + /* implicitly at the paraLevel (rule (L1)) - levels may not reflect that */ + int32_t trailingWSStart; + + /* fields for paragraph handling */ + int32_t paraCount; /* set in getDirProps() */ + Para *paras; /* limits of paragraphs, filled in + ResolveExplicitLevels() or CheckExplicitLevels() */ + + /* for single paragraph text, we only need a tiny array of paras (no malloc()) */ + Para simpleParas[1]; + + /* fields for line reordering */ + int32_t runCount; /* ==-1: runs not set up yet */ + Run *runs; + + /* for non-mixed text, we only need a tiny array of runs (no malloc()) */ + Run simpleRuns[1]; +}; + +#define IS_VALID_PARA(x) ((x) && ((x)->pParaBiDi==(x))) +#define IS_VALID_LINE(x) ((x) && ((x)->pParaBiDi) && ((x)->pParaBiDi->pParaBiDi==(x)->pParaBiDi)) +#define IS_VALID_PARA_OR_LINE(x) ((x) && ((x)->pParaBiDi==(x) || (((x)->pParaBiDi) && (x)->pParaBiDi->pParaBiDi==(x)->pParaBiDi))) + +/* helper function to (re)allocate memory if allowed */ +U_CFUNC UBool +ubidi_getMemory(void **pMemory, int32_t *pSize, UBool mayAllocate, int32_t sizeNeeded); + +/* helper macros for each allocated array in UBiDi */ +#define getDirPropsMemory(pBiDi, length) \ + ubidi_getMemory((void **)&(pBiDi)->dirPropsMemory, &(pBiDi)->dirPropsSize, \ + (pBiDi)->mayAllocateText, (length)) + +#define getLevelsMemory(pBiDi, length) \ + ubidi_getMemory((void **)&(pBiDi)->levelsMemory, &(pBiDi)->levelsSize, \ + (pBiDi)->mayAllocateText, (length)) + +#define getRunsMemory(pBiDi, length) \ + ubidi_getMemory((void **)&(pBiDi)->runsMemory, &(pBiDi)->runsSize, \ + (pBiDi)->mayAllocateRuns, (length)*sizeof(Run)) + +/* additional macros used by ubidi_open() - always allow allocation */ +#define getInitialDirPropsMemory(pBiDi, length) \ + ubidi_getMemory((void **)&(pBiDi)->dirPropsMemory, &(pBiDi)->dirPropsSize, \ + TRUE, (length)) + +#define getInitialLevelsMemory(pBiDi, length) \ + ubidi_getMemory((void **)&(pBiDi)->levelsMemory, &(pBiDi)->levelsSize, \ + TRUE, (length)) + +#define getInitialParasMemory(pBiDi, length) \ + ubidi_getMemory((void **)&(pBiDi)->parasMemory, &(pBiDi)->parasSize, \ + TRUE, (length)*sizeof(Para)) + +#define getInitialRunsMemory(pBiDi, length) \ + ubidi_getMemory((void **)&(pBiDi)->runsMemory, &(pBiDi)->runsSize, \ + TRUE, (length)*sizeof(Run)) + +#endif + +#endif