266 lines
9.0 KiB
C
266 lines
9.0 KiB
C
/*
|
|
******************************************************************************
|
|
*
|
|
* 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
|