mirror of
https://github.com/unicode-org/icu.git
synced 2025-04-06 05:55:35 +00:00
ICU version 1.3 merge from CMVS.
git-svn-id: http://source.icu-project.org/repos/icu/icu/trunk@9 0a8b766c-62c9-45f9-954d-7f2943c9ead0
This commit is contained in:
Helena Chapman
parent
f32a233805
commit
4e538cacc8
36 changed files with 17787 additions and 2140 deletions
10617
data/UnicodeData-3.0.0.txt
Normal file
10617
data/UnicodeData-3.0.0.txt
Normal file
File diff suppressed because it is too large
Load diff
|
|
@ -9,7 +9,7 @@
|
|||
<body>
|
||||
<b>
|
||||
|
||||
<p ALIGN="CENTER"><big>IBM PUBLIC LICENSE - IBM’s Classes for Unicode VERSION 1.2.3</big></p>
|
||||
<p ALIGN="CENTER"><big>IBM PUBLIC LICENSE - IBM’s Classes for Unicode VERSION 1.3</big></p>
|
||||
</b><font size="2">
|
||||
|
||||
<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS IBM PUBLIC LICENSE
|
||||
|
|
|
|||
|
|
@ -99,7 +99,7 @@ install-local:
|
|||
|
||||
## Generate HTML documentation
|
||||
doc:
|
||||
@uniq=`date '+%y%m%d8/20/99M%S'`; \
|
||||
@uniq=`date '+%y%m%d9/30/99M%S'`; \
|
||||
tmpdir="/tmp/icu-$$uniq"; \
|
||||
list='$(DOCDIRS)'; for subdir in $$list; do \
|
||||
echo "Making install-headers in $$subdir"; \
|
||||
|
|
|
|||
|
|
@ -58,14 +58,15 @@ cpputils.o cstring.o dcmpdata.o digitlst.o filestrm.o locid.o locmap.o \
|
|||
mutex.o normlzr.o putil.o rbcache.o resbund.o schriter.o scsu.o \
|
||||
uchar.o uchriter.o ucmp8.o ucmp16.o ucmp32.o ucnv.o ucnv_bld.o \
|
||||
ucnv_cnv.o ucnv_err.o ucnv_io.o uhash.o uloc.o unicode.o unistr.o \
|
||||
ures.o ustring.o rbread.o rbdata.o
|
||||
ures.o ustring.o rbread.o rbdata.o ubidi.o ubidiln.o bidi.o
|
||||
|
||||
DEPS = $(OBJECTS:.o=.d)
|
||||
|
||||
## Header files to install
|
||||
HEADERS= utypes.h uloc.h ures.h ustring.h uchar.h chariter.h \
|
||||
HEADERS = utypes.h uloc.h ures.h ustring.h uchar.h chariter.h \
|
||||
uchriter.h locid.h resbund.h unicode.h putil.h platform.h unistr.h \
|
||||
schriter.h normlzr.h ucnv_err.h ucnv.h ucnv_bld.h convert.h
|
||||
schriter.h normlzr.h ucnv_err.h ucnv.h ucnv_bld.h convert.h \
|
||||
ubidi.h bidi.h
|
||||
|
||||
## List of phony targets
|
||||
.PHONY : all all-local install install-local clean clean-local \
|
||||
|
|
|
|||
26
source/common/bidi.cpp
Normal file
26
source/common/bidi.cpp
Normal file
|
|
@ -0,0 +1,26 @@
|
|||
/*
|
||||
*******************************************************************************
|
||||
* *
|
||||
* COPYRIGHT: *
|
||||
* (C) Copyright International Business Machines Corporation, 1999 *
|
||||
* Licensed Material - Program-Property of IBM - All Rights Reserved. *
|
||||
* US Government Users Restricted Rights - Use, duplication, or disclosure *
|
||||
* restricted by GSA ADP Schedule Contract with IBM Corp. *
|
||||
* *
|
||||
*******************************************************************************
|
||||
* file name: bidi.cpp
|
||||
* encoding: US-ASCII
|
||||
* tab size: 8 (not used)
|
||||
* indentation:4
|
||||
*
|
||||
* created on: 1999sep15
|
||||
* created by: Markus W. Scherer
|
||||
*/
|
||||
|
||||
/* set import/export definitions */
|
||||
#ifndef U_COMMON_IMPLEMENTATION
|
||||
# define U_COMMON_IMPLEMENTATION
|
||||
#endif
|
||||
|
||||
// provide an object for the implementations of the member functions of BiDi
|
||||
#include "bidi.h"
|
||||
258
source/common/bidi.h
Normal file
258
source/common/bidi.h
Normal file
|
|
@ -0,0 +1,258 @@
|
|||
/*
|
||||
*******************************************************************************
|
||||
* *
|
||||
* COPYRIGHT: *
|
||||
* (C) Copyright International Business Machines Corporation, 1999 *
|
||||
* Licensed Material - Program-Property of IBM - All Rights Reserved. *
|
||||
* US Government Users Restricted Rights - Use, duplication, or disclosure *
|
||||
* restricted by GSA ADP Schedule Contract with IBM Corp. *
|
||||
* *
|
||||
*******************************************************************************
|
||||
* file name: ubidi.h
|
||||
* encoding: US-ASCII
|
||||
* tab size: 8 (not used)
|
||||
* indentation:4
|
||||
*
|
||||
* created on: 1999sep15
|
||||
* created by: Markus W. Scherer
|
||||
*/
|
||||
|
||||
#ifndef BIDI_H
|
||||
#define BIDI_H
|
||||
|
||||
#include "utypes.h"
|
||||
#include "ubidi.h"
|
||||
|
||||
#ifndef XP_CPLUSPLUS
|
||||
# error This is a C++ header file.
|
||||
#endif
|
||||
|
||||
/**
|
||||
* BiDi is a C++ wrapper class for UBiDi.
|
||||
* You need one BiDi object in place of one UBiDi object.
|
||||
* For details on the API and implementation of the
|
||||
* Unicode BiDi algorithm, see ubidi.h.
|
||||
*
|
||||
* @see UBiDi
|
||||
*/
|
||||
class U_COMMON_API BiDi {
|
||||
public:
|
||||
/** @memo Default constructor, calls ubidi_open(). */
|
||||
BiDi();
|
||||
|
||||
/** @memo Constructor, calls ubidi_open(). */
|
||||
BiDi(UErrorCode &rErrorCode);
|
||||
|
||||
/** @memo Preallocating constructor, calls ubidi_openSized(). */
|
||||
BiDi(UTextOffset maxLength, UTextOffset maxRunCount, UErrorCode &rErrorCode);
|
||||
|
||||
/** @memo Destructor, calls ubidi_close(). */
|
||||
~BiDi();
|
||||
|
||||
/** @memo Set this object for one paragraph's text. */
|
||||
BiDi &
|
||||
setPara(const UChar *text, UTextOffset length,
|
||||
UBiDiLevel paraLevel, UBiDiLevel *embeddingLevels,
|
||||
UErrorCode &rErrorCode);
|
||||
|
||||
|
||||
/** @memo Set this object for one line of the paragraph object's text. */
|
||||
BiDi &
|
||||
setLine(const BiDi &rParaBiDi,
|
||||
UTextOffset start, UTextOffset limit,
|
||||
UErrorCode &rErrorCode);
|
||||
|
||||
/** @memo Get the directionality of the text. */
|
||||
UBiDiDirection
|
||||
getDirection() const;
|
||||
|
||||
/** @memo Get the length of the text. */
|
||||
UTextOffset
|
||||
getLength() const;
|
||||
|
||||
/** @memo Get the paragraph level of the text. */
|
||||
UBiDiLevel
|
||||
getParaLevel() const;
|
||||
|
||||
/** @memo Get the level for one character. */
|
||||
UBiDiLevel
|
||||
getLevelAt(UTextOffset charIndex) const;
|
||||
|
||||
/** @memo Get an array of levels for each character. */
|
||||
const UBiDiLevel *
|
||||
getLevels(UErrorCode &rErrorCode);
|
||||
|
||||
/** @memo Get a logical run. */
|
||||
void
|
||||
getLogicalRun(UTextOffset logicalStart,
|
||||
UTextOffset &rLogicalLimit, UBiDiLevel &rLevel) const;
|
||||
|
||||
/** @memo Get the number of runs. */
|
||||
UTextOffset
|
||||
countRuns(UErrorCode &rErrorCode);
|
||||
|
||||
/**
|
||||
* @memo Get one run's logical start, length, and directionality,
|
||||
* which can be 0 for LTR or 1 for RTL.
|
||||
*/
|
||||
UBiDiDirection
|
||||
getVisualRun(UTextOffset runIndex, UTextOffset &rLogicalStart, UTextOffset &rLength);
|
||||
|
||||
/** @memo Get the visual position from a logical text position. */
|
||||
UTextOffset
|
||||
getVisualIndex(UTextOffset logicalIndex, UErrorCode &rErrorCode);
|
||||
|
||||
/** @memo Get the logical text position from a visual position. */
|
||||
UTextOffset
|
||||
getLogicalIndex(UTextOffset visualIndex, UErrorCode &rErrorCode);
|
||||
|
||||
/**
|
||||
* @memo Get a logical-to-visual index map (array) for the characters in the UBiDi
|
||||
* (paragraph or line) object.
|
||||
*/
|
||||
void
|
||||
getLogicalMap(UTextOffset *indexMap, UErrorCode &rErrorCode);
|
||||
|
||||
/**
|
||||
* @memo Get a visual-to-logical index map (array) for the characters in the UBiDi
|
||||
* (paragraph or line) object.
|
||||
*/
|
||||
void
|
||||
getVisualMap(UTextOffset *indexMap, UErrorCode &rErrorCode);
|
||||
|
||||
/** @memo Same as ubidi_reorderLogical(). */
|
||||
static void
|
||||
reorderLogical(const UBiDiLevel *levels, UTextOffset length, UTextOffset *indexMap);
|
||||
|
||||
/** @memo Same as ubidi_reorderVisual(). */
|
||||
static void
|
||||
reorderVisual(const UBiDiLevel *levels, UTextOffset length, UTextOffset *indexMap);
|
||||
|
||||
/** @memo Same as ubidi_invertMap(). */
|
||||
static void
|
||||
invertMap(const UTextOffset *srcMap, UTextOffset *destMap, UTextOffset length);
|
||||
|
||||
protected:
|
||||
UBiDi *pBiDi;
|
||||
};
|
||||
|
||||
/* Inline implementations. -------------------------------------------------- */
|
||||
|
||||
inline BiDi::BiDi() {
|
||||
pBiDi=ubidi_open();
|
||||
}
|
||||
|
||||
inline BiDi::BiDi(UErrorCode &rErrorCode) {
|
||||
if(SUCCESS(rErrorCode)) {
|
||||
pBiDi=ubidi_open();
|
||||
if(pBiDi==0) {
|
||||
rErrorCode=MEMORY_ALLOCATION_ERROR;
|
||||
}
|
||||
} else {
|
||||
pBiDi=0;
|
||||
}
|
||||
}
|
||||
|
||||
inline BiDi::BiDi(UTextOffset maxLength, UTextOffset maxRunCount, UErrorCode &rErrorCode) {
|
||||
pBiDi=ubidi_openSized(maxLength, maxRunCount, &rErrorCode);
|
||||
}
|
||||
|
||||
inline BiDi::~BiDi() {
|
||||
ubidi_close(pBiDi);
|
||||
pBiDi=0;
|
||||
}
|
||||
|
||||
inline BiDi &
|
||||
BiDi::setPara(const UChar *text, UTextOffset length,
|
||||
UBiDiLevel paraLevel, UBiDiLevel *embeddingLevels,
|
||||
UErrorCode &rErrorCode) {
|
||||
ubidi_setPara(pBiDi, text, length, paraLevel, embeddingLevels, &rErrorCode);
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
inline BiDi &
|
||||
BiDi::setLine(const BiDi &rParaBiDi,
|
||||
UTextOffset start, UTextOffset limit,
|
||||
UErrorCode &rErrorCode) {
|
||||
ubidi_setLine(rParaBiDi.pBiDi, start, limit, pBiDi, &rErrorCode);
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline UBiDiDirection
|
||||
BiDi::getDirection() const {
|
||||
return ubidi_getDirection(pBiDi);
|
||||
}
|
||||
|
||||
inline UTextOffset
|
||||
BiDi::getLength() const {
|
||||
return ubidi_getLength(pBiDi);
|
||||
}
|
||||
|
||||
inline UBiDiLevel
|
||||
BiDi::getParaLevel() const {
|
||||
return ubidi_getParaLevel(pBiDi);
|
||||
}
|
||||
|
||||
inline UBiDiLevel
|
||||
BiDi::getLevelAt(UTextOffset charIndex) const {
|
||||
return ubidi_getLevelAt(pBiDi, charIndex);
|
||||
}
|
||||
|
||||
inline const UBiDiLevel *
|
||||
BiDi::getLevels(UErrorCode &rErrorCode) {
|
||||
return ubidi_getLevels(pBiDi, &rErrorCode);
|
||||
}
|
||||
|
||||
inline void
|
||||
BiDi::getLogicalRun(UTextOffset logicalStart,
|
||||
UTextOffset &rLogicalLimit, UBiDiLevel &rLevel) const {
|
||||
ubidi_getLogicalRun(pBiDi, logicalStart, &rLogicalLimit, &rLevel);
|
||||
}
|
||||
|
||||
inline UTextOffset
|
||||
BiDi::countRuns(UErrorCode &rErrorCode) {
|
||||
return ubidi_countRuns(pBiDi, &rErrorCode);
|
||||
}
|
||||
|
||||
inline UBiDiDirection
|
||||
BiDi::getVisualRun(UTextOffset runIndex, UTextOffset &rLogicalStart, UTextOffset &rLength) {
|
||||
return ubidi_getVisualRun(pBiDi, runIndex, &rLogicalStart, &rLength);
|
||||
}
|
||||
|
||||
inline UTextOffset
|
||||
BiDi::getVisualIndex(UTextOffset logicalIndex, UErrorCode &rErrorCode) {
|
||||
return ubidi_getVisualIndex(pBiDi, logicalIndex, &rErrorCode);
|
||||
}
|
||||
|
||||
inline UTextOffset
|
||||
BiDi::getLogicalIndex(UTextOffset visualIndex, UErrorCode &rErrorCode) {
|
||||
return ubidi_getLogicalIndex(pBiDi, visualIndex, &rErrorCode);
|
||||
}
|
||||
|
||||
inline void
|
||||
BiDi::getLogicalMap(UTextOffset *indexMap, UErrorCode &rErrorCode) {
|
||||
ubidi_getLogicalMap(pBiDi, indexMap, &rErrorCode);
|
||||
}
|
||||
|
||||
inline void
|
||||
BiDi::getVisualMap(UTextOffset *indexMap, UErrorCode &rErrorCode) {
|
||||
ubidi_getVisualMap(pBiDi, indexMap, &rErrorCode);
|
||||
}
|
||||
|
||||
inline void
|
||||
BiDi::reorderLogical(const UBiDiLevel *levels, UTextOffset length, UTextOffset *indexMap) {
|
||||
ubidi_reorderLogical(levels, length, indexMap);
|
||||
}
|
||||
|
||||
inline void
|
||||
BiDi::reorderVisual(const UBiDiLevel *levels, UTextOffset length, UTextOffset *indexMap) {
|
||||
ubidi_reorderVisual(levels, length, indexMap);
|
||||
}
|
||||
|
||||
inline void
|
||||
BiDi::invertMap(const UTextOffset *srcMap, UTextOffset *destMap, UTextOffset length) {
|
||||
ubidi_invertMap(srcMap, destMap, length);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -43,7 +43,7 @@ RSC=rc.exe
|
|||
# PROP Ignore_Export_Lib 0
|
||||
# PROP Target_Dir ""
|
||||
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "COMMON_EXPORTS" /YX /FD /c
|
||||
# ADD CPP /nologo /MDd /W3 /GX /I "..\..\include" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "COMMON_EXPORTS" /D "U_COMMON_IMPLEMENTATION" /YX /FD /c
|
||||
# ADD CPP /nologo /MDd /Za /W3 /GX /I "..\..\include" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "COMMON_EXPORTS" /D "U_COMMON_IMPLEMENTATION" /YX /FD /c
|
||||
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
|
||||
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
|
||||
# ADD BASE RSC /l 0x409 /d "NDEBUG"
|
||||
|
|
@ -69,7 +69,7 @@ LINK32=link.exe
|
|||
# PROP Ignore_Export_Lib 0
|
||||
# PROP Target_Dir ""
|
||||
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "COMMON_EXPORTS" /YX /FD /GZ /c
|
||||
# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "..\..\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "COMMON_EXPORTS" /D "U_COMMON_IMPLEMENTATION" /YX /FD /GZ /c
|
||||
# ADD CPP /nologo /MDd /Za /W3 /Gm /GX /ZI /Od /I "..\..\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "COMMON_EXPORTS" /D "U_COMMON_IMPLEMENTATION" /YX /FD /GZ /c
|
||||
# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
|
||||
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
|
||||
# ADD BASE RSC /l 0x409 /d "_DEBUG"
|
||||
|
|
@ -92,6 +92,10 @@ LINK32=link.exe
|
|||
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\bidi.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\chariter.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
|
@ -145,6 +149,7 @@ SOURCE=.\normlzr.cpp
|
|||
# Begin Source File
|
||||
|
||||
SOURCE=.\putil.c
|
||||
# ADD CPP /Ze
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
|
|
@ -161,6 +166,7 @@ SOURCE=.\rbread.cpp
|
|||
# Begin Source File
|
||||
|
||||
SOURCE=.\resbund.cpp
|
||||
# ADD CPP /Ze
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
|
|
@ -172,6 +178,14 @@ SOURCE=.\scsu.c
|
|||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\ubidi.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\ubidiln.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\uchar.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
|
@ -221,6 +235,7 @@ SOURCE=.\uloc.c
|
|||
# Begin Source File
|
||||
|
||||
SOURCE=.\umutex.c
|
||||
# ADD CPP /Ze
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
|
|
@ -244,6 +259,33 @@ SOURCE=.\ustring.c
|
|||
# PROP Default_Filter "h;hpp;hxx;hm;inl"
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\bidi.h
|
||||
|
||||
!IF "$(CFG)" == "common - Win32 Release"
|
||||
|
||||
# Begin Custom Build
|
||||
InputPath=.\bidi.h
|
||||
|
||||
"..\..\include\bidi.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy bidi.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
!ELSEIF "$(CFG)" == "common - Win32 Debug"
|
||||
|
||||
# Begin Custom Build
|
||||
InputPath=.\bidi.h
|
||||
|
||||
"..\..\include\bidi.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy bidi.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\chariter.h
|
||||
|
||||
!IF "$(CFG)" == "common - Win32 Release"
|
||||
|
|
@ -252,7 +294,7 @@ SOURCE=.\chariter.h
|
|||
InputPath=.\chariter.h
|
||||
|
||||
"..\..\include\chariter.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy chariter.h ..\..\include\
|
||||
copy chariter.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -262,7 +304,7 @@ InputPath=.\chariter.h
|
|||
InputPath=.\chariter.h
|
||||
|
||||
"..\..\include\chariter.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy chariter.h ..\..\include\
|
||||
copy chariter.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -291,7 +333,7 @@ SOURCE=.\convert.h
|
|||
InputPath=.\convert.h
|
||||
|
||||
"..\..\include\convert.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy convert.h ..\..\include\
|
||||
copy convert.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -301,7 +343,7 @@ InputPath=.\convert.h
|
|||
InputPath=.\convert.h
|
||||
|
||||
"..\..\include\convert.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy convert.h ..\..\include\
|
||||
copy convert.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -338,7 +380,7 @@ SOURCE=.\locid.h
|
|||
InputPath=.\locid.h
|
||||
|
||||
"..\..\include\locid.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy locid.h ..\..\include\
|
||||
copy locid.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -348,7 +390,7 @@ InputPath=.\locid.h
|
|||
InputPath=.\locid.h
|
||||
|
||||
"..\..\include\locid.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy locid.h ..\..\include\
|
||||
copy locid.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -373,7 +415,7 @@ SOURCE=.\normlzr.h
|
|||
InputPath=.\normlzr.h
|
||||
|
||||
"..\..\include\normlzr.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy normlzr.h ..\..\include\
|
||||
copy normlzr.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -383,7 +425,7 @@ InputPath=.\normlzr.h
|
|||
InputPath=.\normlzr.h
|
||||
|
||||
"..\..\include\normlzr.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy normlzr.h ..\..\include\
|
||||
copy normlzr.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -400,7 +442,7 @@ SOURCE=.\putil.h
|
|||
InputPath=.\putil.h
|
||||
|
||||
"..\..\include\putil.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy putil.h ..\..\include\
|
||||
copy putil.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -410,7 +452,7 @@ InputPath=.\putil.h
|
|||
InputPath=.\putil.h
|
||||
|
||||
"..\..\include\putil.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy putil.h ..\..\include\
|
||||
copy putil.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -427,7 +469,7 @@ SOURCE=.\pwin32.h
|
|||
InputPath=.\pwin32.h
|
||||
|
||||
"..\..\include\pwin32.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy pwin32.h ..\..\include\
|
||||
copy pwin32.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -437,7 +479,7 @@ InputPath=.\pwin32.h
|
|||
InputPath=.\pwin32.h
|
||||
|
||||
"..\..\include\pwin32.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy pwin32.h ..\..\include\
|
||||
copy pwin32.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -466,7 +508,7 @@ SOURCE=.\resbund.h
|
|||
InputPath=.\resbund.h
|
||||
|
||||
"..\..\include\resbund.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy resbund.h ..\..\include\
|
||||
copy resbund.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -476,7 +518,7 @@ InputPath=.\resbund.h
|
|||
InputPath=.\resbund.h
|
||||
|
||||
"..\..\include\resbund.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy resbund.h ..\..\include\
|
||||
copy resbund.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -493,7 +535,7 @@ SOURCE=.\schriter.h
|
|||
InputPath=.\schriter.h
|
||||
|
||||
"..\..\include\schriter.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy schriter.h ..\..\include\
|
||||
copy schriter.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -503,7 +545,7 @@ InputPath=.\schriter.h
|
|||
InputPath=.\schriter.h
|
||||
|
||||
"..\..\include\schriter.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy schriter.h ..\..\include\
|
||||
copy schriter.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -520,7 +562,7 @@ SOURCE=.\scsu.h
|
|||
InputPath=.\scsu.h
|
||||
|
||||
"..\..\include\scsu.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy scsu.h ..\..\include\
|
||||
copy scsu.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -530,7 +572,7 @@ InputPath=.\scsu.h
|
|||
InputPath=.\scsu.h
|
||||
|
||||
"..\..\include\scsu.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy scsu.h ..\..\include\
|
||||
copy scsu.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -539,6 +581,37 @@ InputPath=.\scsu.h
|
|||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\ubidi.h
|
||||
|
||||
!IF "$(CFG)" == "common - Win32 Release"
|
||||
|
||||
# Begin Custom Build
|
||||
InputPath=.\ubidi.h
|
||||
|
||||
"..\..\include\ubidi.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy ubidi.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
!ELSEIF "$(CFG)" == "common - Win32 Debug"
|
||||
|
||||
# Begin Custom Build
|
||||
InputPath=.\ubidi.h
|
||||
|
||||
"..\..\include\ubidi.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy ubidi.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\ubidiimp.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\uchar.h
|
||||
|
||||
!IF "$(CFG)" == "common - Win32 Release"
|
||||
|
|
@ -547,7 +620,7 @@ SOURCE=.\uchar.h
|
|||
InputPath=.\uchar.h
|
||||
|
||||
"..\..\include\uchar.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy uchar.h ..\..\include\
|
||||
copy uchar.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -557,7 +630,7 @@ InputPath=.\uchar.h
|
|||
InputPath=.\uchar.h
|
||||
|
||||
"..\..\include\uchar.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy uchar.h ..\..\include\
|
||||
copy uchar.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -574,7 +647,7 @@ SOURCE=.\uchriter.h
|
|||
InputPath=.\uchriter.h
|
||||
|
||||
"..\..\include\uchriter.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy uchriter.h ..\..\include\
|
||||
copy uchriter.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -584,7 +657,7 @@ InputPath=.\uchriter.h
|
|||
InputPath=.\uchriter.h
|
||||
|
||||
"..\..\include\uchriter.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy uchriter.h ..\..\include\
|
||||
copy uchriter.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -613,7 +686,7 @@ SOURCE=.\ucnv.h
|
|||
InputPath=.\ucnv.h
|
||||
|
||||
"..\..\include\ucnv.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy ucnv.h ..\..\include\
|
||||
copy ucnv.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -623,7 +696,7 @@ InputPath=.\ucnv.h
|
|||
InputPath=.\ucnv.h
|
||||
|
||||
"..\..\include\ucnv.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy ucnv.h ..\..\include\
|
||||
copy ucnv.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -640,7 +713,7 @@ SOURCE=.\ucnv_bld.h
|
|||
InputPath=.\ucnv_bld.h
|
||||
|
||||
"..\..\include\ucnv_bld.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy ucnv_bld.h ..\..\include\
|
||||
copy ucnv_bld.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -650,7 +723,7 @@ InputPath=.\ucnv_bld.h
|
|||
InputPath=.\ucnv_bld.h
|
||||
|
||||
"..\..\include\ucnv_bld.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy ucnv_bld.h ..\..\include\
|
||||
copy ucnv_bld.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -671,7 +744,7 @@ SOURCE=.\ucnv_err.h
|
|||
InputPath=.\ucnv_err.h
|
||||
|
||||
"..\..\include\ucnv_err.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy ucnv_err.h ..\..\include\
|
||||
copy ucnv_err.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -681,7 +754,7 @@ InputPath=.\ucnv_err.h
|
|||
InputPath=.\ucnv_err.h
|
||||
|
||||
"..\..\include\ucnv_err.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy ucnv_err.h ..\..\include\
|
||||
copy ucnv_err.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -706,7 +779,7 @@ SOURCE=.\uloc.h
|
|||
InputPath=.\uloc.h
|
||||
|
||||
"..\..\include\uloc.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy uloc.h ..\..\include\
|
||||
copy uloc.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -716,7 +789,7 @@ InputPath=.\uloc.h
|
|||
InputPath=.\uloc.h
|
||||
|
||||
"..\..\include\uloc.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy uloc.h ..\..\include\
|
||||
copy uloc.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -737,7 +810,7 @@ SOURCE=.\unicode.h
|
|||
InputPath=.\unicode.h
|
||||
|
||||
"..\..\include\unicode.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy unicode.h ..\..\include\
|
||||
copy unicode.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -747,7 +820,7 @@ InputPath=.\unicode.h
|
|||
InputPath=.\unicode.h
|
||||
|
||||
"..\..\include\unicode.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy unicode.h ..\..\include\
|
||||
copy unicode.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -764,7 +837,7 @@ SOURCE=.\unistr.h
|
|||
InputPath=.\unistr.h
|
||||
|
||||
"..\..\include\unistr.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy unistr.h ..\..\include\
|
||||
copy unistr.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -774,7 +847,7 @@ InputPath=.\unistr.h
|
|||
InputPath=.\unistr.h
|
||||
|
||||
"..\..\include\unistr.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy unistr.h ..\..\include\
|
||||
copy unistr.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -795,7 +868,7 @@ SOURCE=.\ures.h
|
|||
InputPath=.\ures.h
|
||||
|
||||
"..\..\include\ures.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy ures.h ..\..\include\
|
||||
copy ures.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -805,7 +878,7 @@ InputPath=.\ures.h
|
|||
InputPath=.\ures.h
|
||||
|
||||
"..\..\include\ures.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy ures.h ..\..\include\
|
||||
copy ures.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -822,7 +895,7 @@ SOURCE=.\ustring.h
|
|||
InputPath=.\ustring.h
|
||||
|
||||
"..\..\include\ustring.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy ustring.h ..\..\include\
|
||||
copy ustring.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -832,7 +905,7 @@ InputPath=.\ustring.h
|
|||
InputPath=.\ustring.h
|
||||
|
||||
"..\..\include\ustring.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy ustring.h ..\..\include\
|
||||
copy ustring.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -849,7 +922,7 @@ SOURCE=.\utypes.h
|
|||
InputPath=.\utypes.h
|
||||
|
||||
"..\..\include\utypes.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy utypes.h ..\..\include\
|
||||
copy utypes.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
@ -859,7 +932,7 @@ InputPath=.\utypes.h
|
|||
InputPath=.\utypes.h
|
||||
|
||||
"..\..\include\utypes.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
copy utypes.h ..\..\include\
|
||||
copy utypes.h ..\..\include\
|
||||
|
||||
# End Custom Build
|
||||
|
||||
|
|
|
|||
|
|
@ -758,11 +758,11 @@ Locale::getLanguagesForCountry(const UnicodeString& country, int32_t& count)
|
|||
// lookups.
|
||||
if(ctry2LangMapping == 0) {
|
||||
UErrorCode err = ZERO_ERROR;
|
||||
UHashtable *temp = uhash_openSize((UHashFunction)uhash_hashUString, 200, &err);
|
||||
UHashtable *temp = uhash_open(uhash_hashUString, &err);
|
||||
if (FAILURE(err))
|
||||
{
|
||||
count = 0;
|
||||
return NULL;
|
||||
count = 0;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int32_t i = 0;
|
||||
|
|
|
|||
|
|
@ -678,12 +678,16 @@ icu_getDefaultDataDirectory()
|
|||
#endif
|
||||
|
||||
#ifdef WIN32
|
||||
return "\\icu\\data\\";
|
||||
char * dpath;
|
||||
dpath = getenv("ICU_DATA");
|
||||
if (!dpath || !*dpath)
|
||||
return "\\icu\\data\\";
|
||||
return dpath;
|
||||
#endif
|
||||
|
||||
#ifdef OS2
|
||||
char * dpath;
|
||||
dpath = getenv("ICUPATH");
|
||||
dpath = getenv("ICU_DATA");
|
||||
if (!dpath || !*dpath)
|
||||
return "\\icu\\data\\";
|
||||
return dpath;
|
||||
|
|
|
|||
2117
source/common/scsu.c
2117
source/common/scsu.c
File diff suppressed because it is too large
Load diff
|
|
@ -15,6 +15,7 @@
|
|||
*
|
||||
* Date Name Description
|
||||
* 05/17/99 stephen Creation (ported from java UnicodeCompressor.java)
|
||||
* 09/21/99 stephen Updated to handle data splits on decompression.
|
||||
*******************************************************************************
|
||||
*/
|
||||
|
||||
|
|
@ -30,6 +31,9 @@
|
|||
/* Maximum value for a window's index */
|
||||
#define MAXINDEX 0xFF
|
||||
|
||||
/** The size of the internal buffer for a UnicodeCompressor */
|
||||
#define SCSU_BUFSIZE 3
|
||||
|
||||
/** The UnicodeCompressor struct */
|
||||
struct UnicodeCompressor {
|
||||
|
||||
|
|
@ -50,6 +54,12 @@ struct UnicodeCompressor {
|
|||
|
||||
/** The current time stamp */
|
||||
int32_t fTimeStamp;
|
||||
|
||||
/** Internal buffer for saving state */
|
||||
uint8_t fBuffer [ SCSU_BUFSIZE ];
|
||||
|
||||
/** Number of characters in our internal buffer */
|
||||
int32_t fBufferLength;
|
||||
};
|
||||
typedef struct UnicodeCompressor UnicodeCompressor;
|
||||
|
||||
|
|
@ -101,8 +111,8 @@ CAPI void U_EXPORT2 scsu_compress(UnicodeCompressor *comp,
|
|||
/**
|
||||
* Decompress a byte array into a Unicode character array.
|
||||
*
|
||||
* This function is not guaranteed to completely fill the output buffer, nor
|
||||
* is it guaranteed to compress the entire input.
|
||||
* This function will either completely fill the output buffer, or
|
||||
* consume the entire input.
|
||||
* If the source data is completely compressed, <TT>status</TT> will be set
|
||||
* to <TT>ZERO_ERROR</TT>.
|
||||
* If the source data is not completely compressed, <TT>status</TT> will be
|
||||
|
|
@ -110,7 +120,7 @@ CAPI void U_EXPORT2 scsu_compress(UnicodeCompressor *comp,
|
|||
* should be allocated, or data flushed, and the function should be called
|
||||
* again with the new buffers.
|
||||
*
|
||||
* @param comp A pointer to a previously-initialized UnicodeCompressor
|
||||
* @param comp A pointer to a previously-initialized UnicodeDecompressor
|
||||
* @param target I/O parameter. On input, a pointer to a buffer of Unicode
|
||||
* characters to receive the compressed data. On output, points to the
|
||||
* character following the last character written. This buffer must be
|
||||
|
|
@ -121,6 +131,7 @@ CAPI void U_EXPORT2 scsu_compress(UnicodeCompressor *comp,
|
|||
* last byte decompressed.
|
||||
* @param sourceLimit A pointer to the end of the array <TT>source</TT>.
|
||||
* @param status A pointer to an UErrorCode to receive any errors.
|
||||
* @return The number of Unicode characters writeten to <TT>target</TT>.
|
||||
*
|
||||
* @see #compress
|
||||
*/
|
||||
|
|
|
|||
1291
source/common/ubidi.c
Normal file
1291
source/common/ubidi.c
Normal file
File diff suppressed because it is too large
Load diff
888
source/common/ubidi.h
Normal file
888
source/common/ubidi.h
Normal file
|
|
@ -0,0 +1,888 @@
|
|||
/*
|
||||
*******************************************************************************
|
||||
* *
|
||||
* COPYRIGHT: *
|
||||
* (C) Copyright International Business Machines Corporation, 1999 *
|
||||
* Licensed Material - Program-Property of IBM - All Rights Reserved. *
|
||||
* US Government Users Restricted Rights - Use, duplication, or disclosure *
|
||||
* restricted by GSA ADP Schedule Contract with IBM Corp. *
|
||||
* *
|
||||
*******************************************************************************
|
||||
* file name: ubidi.h
|
||||
* encoding: US-ASCII
|
||||
* tab size: 8 (not used)
|
||||
* indentation:4
|
||||
*
|
||||
* created on: 1999jul27
|
||||
* created by: Markus W. Scherer
|
||||
*/
|
||||
|
||||
#ifndef UBIDI_H
|
||||
#define UBIDI_H
|
||||
|
||||
#include "utypes.h"
|
||||
#include "uchar.h"
|
||||
|
||||
/*
|
||||
* javadoc-style comments are intended to be transformed into HTML
|
||||
* using DOC++ - see
|
||||
* http://www.zib.de/Visual/software/doc++/index.html .
|
||||
*
|
||||
* The HTML documentation is created with
|
||||
* doc++ -H ubidi.h
|
||||
*
|
||||
* The following #define trick allows us to do it all in one file
|
||||
* and still be able to compile it.
|
||||
*/
|
||||
#define DOCXX_TAG
|
||||
#define BIDI_SAMPLE_CODE
|
||||
|
||||
/**
|
||||
* @name BiDi algorithm for ICU
|
||||
*
|
||||
* <h2>BiDi algorithm for ICU</h2>
|
||||
*
|
||||
* This is an implementation of the Unicode Bidirectional algorithm.
|
||||
* The algorithm is defined in the
|
||||
* <a href="http://www.unicode.org/unicode/reports/tr9/">Unicode Technical Report 9</a>,
|
||||
* version 5, also described in The Unicode Standard, Version 3.0 .<p>
|
||||
*
|
||||
* <h3>General remarks about the API:</h3>
|
||||
*
|
||||
* In functions with an error code parameter,
|
||||
* the <code>pErrorCode</code> pointer must be valid
|
||||
* and the value that it points to must not indicate a failure before
|
||||
* the function call. Otherwise, the function returns immediately.
|
||||
* After the function call, the value indicates success or failure.<p>
|
||||
*
|
||||
* The <quote>limit</quote> of a sequence of characters is the position just after their
|
||||
* last character, i.e., one more than that position.<p>
|
||||
*
|
||||
* Some of the API functions provide access to <quote>runs</quote>.
|
||||
* Such a <quote>run</quote> is defined as a sequence of characters
|
||||
* that are at the same embedding level
|
||||
* after performing the BiDi algorithm.<p>
|
||||
*
|
||||
* @author Markus W. Scherer
|
||||
* @version 1.0
|
||||
*/
|
||||
DOCXX_TAG
|
||||
/*@{*/
|
||||
|
||||
/**
|
||||
* UBiDiLevel is the type of the level values in this
|
||||
* BiDi implementation.
|
||||
* It holds an embedding level and indicates the visual direction
|
||||
* by its bit 0 (even/odd value).<p>
|
||||
*
|
||||
* It can also hold non-level values for the
|
||||
* <code>paraLevel</code> and <code>embeddingLevels</code>
|
||||
* arguments of <code>ubidi_setPara()</code>; there:
|
||||
* <ul>
|
||||
* <li>bit 7 of an <code>embeddingLevels[]</code>
|
||||
* value indicates whether the using application is
|
||||
* specifying the level of a character to <i>override</i> whatever the
|
||||
* BiDi implementation would resolve it to.</li>
|
||||
* <li><code>paraLevel</code> can be set to the
|
||||
* pesudo-level values <code>UBIDI_DEFAULT_LTR</code>
|
||||
* and <code>UBIDI_DEFAULT_RTL</code>.</li>
|
||||
*
|
||||
* @see ubidi_setPara
|
||||
*
|
||||
* <p>The related constants are not real, valid level values.
|
||||
* <code>UBIDI_DEFAULT_XXX</code> can be used to specify
|
||||
* a default for the paragraph level for
|
||||
* when the <code>ubidi_setPara()</code> function
|
||||
* shall determine it but there is no
|
||||
* strongly typed character in the input.<p>
|
||||
*
|
||||
* Note that the value for <code>UBIDI_DEFAULT_LTR</code> is even
|
||||
* and the one for <code>UBIDI_DEFAULT_RTL</code> is odd,
|
||||
* just like with normal LTR and RTL level values -
|
||||
* these special values are designed that way. Also, the implementation
|
||||
* assumes that UBIDI_MAX_EXPLICIT_LEVEL is odd.
|
||||
*
|
||||
* @see UBIDI_DEFAULT_LTR
|
||||
* @see UBIDI_DEFAULT_RTL
|
||||
* @see UBIDI_LEVEL_OVERRIDE
|
||||
* @see UBIDI_MAX_EXPLICIT_LEVEL
|
||||
*/
|
||||
typedef uint8_t UBiDiLevel;
|
||||
|
||||
/** @memo If there is no strong character, then set the paragraph level to 0 (left-to-right). */
|
||||
#define UBIDI_DEFAULT_LTR 0xfe
|
||||
|
||||
/** @memo If there is no strong character, then set the paragraph level to 1 (right-to-left). */
|
||||
#define UBIDI_DEFAULT_RTL 0xff
|
||||
|
||||
/**
|
||||
* @memo Maximum explicit embedding level
|
||||
* (The maximum resolved level can be up to <code>UBIDI_MAX_EXPLICIT_LEVEL+1</code>).
|
||||
*/
|
||||
#define UBIDI_MAX_EXPLICIT_LEVEL 61
|
||||
|
||||
/** @memo Bit flag for level input: overrides directional properties. */
|
||||
#define UBIDI_LEVEL_OVERRIDE 0x80
|
||||
|
||||
/**
|
||||
* @memo <code>UBiDiDirection</code> values indicate the text direction.
|
||||
*/
|
||||
enum UBiDiDirection {
|
||||
/** @memo All left-to-right text. This is a 0 value. */
|
||||
UBIDI_LTR,
|
||||
/** @memo All right-to-left text. This is a 1 value. */
|
||||
UBIDI_RTL,
|
||||
/** @memo Mixed-directional text. */
|
||||
UBIDI_MIXED
|
||||
};
|
||||
|
||||
typedef enum UBiDiDirection UBiDiDirection;
|
||||
|
||||
/**
|
||||
* Forward declaration of the <code>UBiDi</code> structure for the declaration of
|
||||
* the API functions. Its fields are implementation-specific.<p>
|
||||
* This structure holds information about a paragraph of text
|
||||
* with BiDi-algorithm-related details, or about one line of
|
||||
* such a paragraph.<p>
|
||||
* Reordering can be done on a line, or on a paragraph which is
|
||||
* then interpreted as one single line.
|
||||
*/
|
||||
struct UBiDi;
|
||||
|
||||
typedef struct UBiDi UBiDi;
|
||||
|
||||
/**
|
||||
* Allocate a <code>UBiDi</code> structure.
|
||||
* Such an object is initially empty. It is assigned
|
||||
* the BiDi properties of a paragraph by <code>ubidi_setPara()</code>
|
||||
* or the BiDi properties of a line of a paragraph by
|
||||
* <code>ubidi_getLine()</code>.<p>
|
||||
* This object can be reused for as long as it is not deallocated
|
||||
* by calling <code>ubidi_close()</code>.<p>
|
||||
* <code>ubidi_set()</code> will allocate additional memory for
|
||||
* internal structures as necessary.
|
||||
*
|
||||
* @return An empty <code>UBiDi</code> object.
|
||||
*/
|
||||
CAPI UBiDi * U_EXPORT2
|
||||
ubidi_open();
|
||||
|
||||
/**
|
||||
* Allocate a <code>UBiDi</code> structure with preallocated memory
|
||||
* for internal structures.
|
||||
* This function provides a <code>UBiDi</code> object like <code>ubidi_open()</code>
|
||||
* with no arguments, but it also preallocates memory for internal structures
|
||||
* according to the sizings supplied by the caller.<p>
|
||||
* Subsequent functions will not allocate any more memory, and are thus
|
||||
* guaranteed not to fail because of lack of memory.<p>
|
||||
* The preallocation can be limited to some of the internal memory
|
||||
* by setting some values to 0 here. That means that if, e.g.,
|
||||
* <code>maxRunCount</code> cannot be reasonably predetermined and should not
|
||||
* be set to <code>maxLength</code> (the only failproof value) to avoid
|
||||
* wasting memory, then <code>maxRunCount</code> could be set to 0 here
|
||||
* and the internal structures that are associated with it will be allocated
|
||||
* on demand, just like with <code>ubidi_open()</code>.
|
||||
*
|
||||
* @param maxLength is the maximum paragraph or line length that internal memory
|
||||
* will be preallocated for. An attempt to associate this object with a
|
||||
* longer text will fail, unless this value is 0, which leaves the allocation
|
||||
* up to the implementation.
|
||||
*
|
||||
* @param maxRunCount is the maximum anticipated number of same-level runs
|
||||
* that internal memory will be preallocated for. An attempt to access
|
||||
* visual runs on an object that was not preallocated for as many runs
|
||||
* as the text was actually resolved to will fail,
|
||||
* unless this value is 0, which leaves the allocation up to the implementation.<p>
|
||||
* The number of runs depends on the actual text and maybe anywhere between
|
||||
* 1 and <code>maxLength</code>. It is typically small.<p>
|
||||
*
|
||||
* @param pErrorCode must be a valid pointer to an error code value,
|
||||
* which must not indicate a failure before the function call.
|
||||
*
|
||||
* @return An empty <code>UBiDi</code> object with preallocated memory.
|
||||
*/
|
||||
CAPI UBiDi * U_EXPORT2
|
||||
ubidi_openSized(UTextOffset maxLength, UTextOffset maxRunCount, UErrorCode *pErrorCode);
|
||||
|
||||
/**
|
||||
* <code>ubidi_close()</code> must be called to free the memory
|
||||
* associated with a UBiDi object.<p>
|
||||
*
|
||||
* <strong>Important: </strong>
|
||||
* If a <code>UBiDi</code> object is the <quote>child</quote>
|
||||
* of another one (its <quote>parent</quote>), after calling
|
||||
* <code>ubidi_setLine()</code>, then the child object must
|
||||
* be destroyed (closed) or reused (by calling
|
||||
* <code>ubidi_setPara()</code> or <code>ubidi_setLine()</code>)
|
||||
* before the parent object.
|
||||
*
|
||||
* @param pBiDi is a <code>UBiDi</code> object.
|
||||
*
|
||||
* @see ubidi_setPara
|
||||
* @see ubidi_setLine
|
||||
*/
|
||||
CAPI void U_EXPORT2
|
||||
ubidi_close(UBiDi *pBiDi);
|
||||
|
||||
/**
|
||||
* Perform the Unicode BiDi algorithm. It is defined in the
|
||||
* <a href="http://www.unicode.org/unicode/reports/tr9/">Unicode Technical Report 9</a>,
|
||||
* version 5,
|
||||
* also described in The Unicode Standard, Version 3.0 .<p>
|
||||
*
|
||||
* This function takes a single plain text paragraph with or without
|
||||
* externally specified embedding levels from <quote>styled</quote> text
|
||||
* and computes the left-right-directionality of each character.<p>
|
||||
*
|
||||
* If the entire paragraph consists of text of only one direction, then
|
||||
* the function may not perform all the steps described by the algorithm,
|
||||
* i.e., some levels may not be the same as if all steps were performed.
|
||||
* This is not relevant for unidirectional text.<br>
|
||||
* For example, in pure LTR text with numbers the numbers would get
|
||||
* a resolved level of 2 higher than the surrounding text according to
|
||||
* the algorithm. This implementation may set all resolved levels to
|
||||
* the same value in such a case.<p>
|
||||
*
|
||||
* The text must be externally split into separate paragraphs (rule P1).
|
||||
* Paragraph separators (B) should appear at most at the very end.
|
||||
*
|
||||
* @param pBiDi A <code>UBiDi</code> object allocated with <code>ubidi_open()</code>
|
||||
* which will be set to contain the reordering information,
|
||||
* especially the resolved levels for all the characters in <code>text</code>.
|
||||
*
|
||||
* @param text is a pointer to the single-paragraph text that the
|
||||
* BiDi algorithm will be performed on
|
||||
* (step (P1) of the algorithm is performed externally).
|
||||
* <strong>The text must be (at least) <code>length</code> long.</strong>
|
||||
*
|
||||
* @param length is the length of the text; if <code>length==-1</code> then
|
||||
* the text must be zero-terminated.
|
||||
*
|
||||
* @param paraLevel specifies the default level for the paragraph;
|
||||
* it is typically 0 (LTR) or 1 (RTL).
|
||||
* If the function shall determine the paragraph level from the text,
|
||||
* then <code>paraLevel</code> can be set to
|
||||
* either <code>UBIDI_DEFAULT_LTR</code>
|
||||
* or <code>UBIDI_DEFAULT_RTL</code>;
|
||||
* if there is no strongly typed character, then
|
||||
* the desired default is used (0 for LTR or 1 for RTL).
|
||||
* Any other value between 0 and <code>UBIDI_MAX_EXPLICIT_LEVEL</code> is also valid,
|
||||
* with odd levels indicating RTL.
|
||||
*
|
||||
* @param embeddingLevels (in) may be used to preset the embedding and override levels,
|
||||
* ignoring characters like LRE and PDF in the text.
|
||||
* A level overrides the directional property of its corresponding
|
||||
* (same index) character if the level has the
|
||||
* <code>UBIDI_LEVEL_OVERRIDE</code> bit set.<p>
|
||||
* Except for that bit, it must be
|
||||
* <code>paraLevel<=embeddingLevels[]<=UBIDI_MAX_EXPLICIT_LEVEL</code>.<p>
|
||||
* <strong>Caution: </strong>A copy of this pointer, not of the levels,
|
||||
* will be stored in the <code>UBiDi</code> object;
|
||||
* the <code>embeddingLevels</code> array must not be
|
||||
* deallocated before the <code>UBiDi</code> structure is destroyed or reused,
|
||||
* and the <code>embeddingLevels</code>
|
||||
* should not be modified to avoid unexpected results on subsequent BiDi operations.
|
||||
* However, the <code>ubidi_setPara()</code> and
|
||||
* <code>ubidi_setLine()</code> functions may modify some or all of the levels.<p>
|
||||
* After the <code>UBiDi</code> object is reused or destroyed, the caller
|
||||
* must take care of the deallocation of the <code>embeddingLevels</code> array.<p>
|
||||
* <strong>The <code>embeddingLevels</code> array must be
|
||||
* at least <code>length</code> long.</strong>
|
||||
*
|
||||
* @param pErrorCode must be a valid pointer to an error code value,
|
||||
* which must not indicate a failure before the function call.
|
||||
*/
|
||||
CAPI void U_EXPORT2
|
||||
ubidi_setPara(UBiDi *pBiDi, const UChar *text, UTextOffset length,
|
||||
UBiDiLevel paraLevel, UBiDiLevel *embeddingLevels,
|
||||
UErrorCode *pErrorCode);
|
||||
|
||||
/**
|
||||
* <code>ubidi_getLine()</code> sets a <code>UBiDi</code> to
|
||||
* contain the reordering information, especially the resolved levels,
|
||||
* for all the characters in a line of text. This line of text is
|
||||
* specified by referring to a <code>UBiDi</code> object representing
|
||||
* this information for a paragraph of text, and by specifying
|
||||
* a range of indexes in this paragraph.<p>
|
||||
* In the new line object, the indexes will range from 0 to <code>limit-start</code>.<p>
|
||||
*
|
||||
* This is used after calling <code>ubidi_setPara()</code>
|
||||
* for a paragraph, and after line-breaking on that paragraph.
|
||||
* It is not necessary if the paragraph is treated as a single line.<p>
|
||||
*
|
||||
* After line-breaking, rules (L1) and (L2) for the treatment of
|
||||
* trailing WS and for reordering are performed on
|
||||
* a <code>UBiDi</code> object that represents a line.<p>
|
||||
*
|
||||
* <strong>Important: </strong><code>pLineBiDi</code> shares data with
|
||||
* <code>pParaBiDi</code>.
|
||||
* You must destroy or reuse <code>pLineBiDi</code> before <code>pParaBiDi</code>.
|
||||
* In other words, you must destroy or reuse the <code>UBiDi</code> object for a line
|
||||
* before the object for its parent paragraph.
|
||||
*
|
||||
* @param pParaBiDi is the parent paragraph object.
|
||||
*
|
||||
* @param start is the line's first index into the paragraph text.
|
||||
*
|
||||
* @param limit is just behind the line's last index into the paragraph text
|
||||
* (its last index +1).<br>
|
||||
* It must be <code>0<=start<=limit<=</code>paragraph length.
|
||||
*
|
||||
* @param pLineBiDi is the object that will now represent a line of the paragraph.
|
||||
*
|
||||
* @param pErrorCode must be a valid pointer to an error code value,
|
||||
* which must not indicate a failure before the function call.
|
||||
*
|
||||
* @see ubidi_setPara
|
||||
*/
|
||||
CAPI void U_EXPORT2
|
||||
ubidi_setLine(const UBiDi *pParaBiDi,
|
||||
UTextOffset start, UTextOffset limit,
|
||||
UBiDi *pLineBiDi,
|
||||
UErrorCode *pErrorCode);
|
||||
|
||||
/**
|
||||
* Get the directionality of the text.
|
||||
*
|
||||
* @param pBiDi is the paragraph or line <code>UBiDi</code> object.
|
||||
*
|
||||
* @return A <code>UBIDI_XXX</code> value that indicates if the entire text
|
||||
* represented by this object is unidirectional,
|
||||
* and which direction, or if it is mixed-directional.
|
||||
*
|
||||
* @see UBiDiDirection
|
||||
*/
|
||||
CAPI UBiDiDirection U_EXPORT2
|
||||
ubidi_getDirection(const UBiDi *pBiDi);
|
||||
|
||||
/**
|
||||
* Get the length of the text.
|
||||
*
|
||||
* @param pBiDi is the paragraph or line <code>UBiDi</code> object.
|
||||
*
|
||||
* @return The length of the text that the UBiDi object was created for.
|
||||
*/
|
||||
CAPI UTextOffset U_EXPORT2
|
||||
ubidi_getLength(const UBiDi *pBiDi);
|
||||
|
||||
/**
|
||||
* Get the paragraph level of the text.
|
||||
*
|
||||
* @param pBiDi is the paragraph or line <code>UBiDi</code> object.
|
||||
*
|
||||
* @return The paragraph level.
|
||||
*
|
||||
* @see UBiDiLevel
|
||||
*/
|
||||
CAPI UBiDiLevel U_EXPORT2
|
||||
ubidi_getParaLevel(const UBiDi *pBiDi);
|
||||
|
||||
/**
|
||||
* Get the level for one character.
|
||||
*
|
||||
* @param pBiDi is the paragraph or line <code>UBiDi</code> object.
|
||||
*
|
||||
* @param charIndex the index of a character.
|
||||
*
|
||||
* @return The level for the character at charIndex.
|
||||
*
|
||||
* @see UBiDiLevel
|
||||
*/
|
||||
CAPI UBiDiLevel U_EXPORT2
|
||||
ubidi_getLevelAt(const UBiDi *pBiDi, UTextOffset charIndex);
|
||||
|
||||
/**
|
||||
* Get an array of levels for each character.<p>
|
||||
*
|
||||
* Note that this function may allocate memory under some
|
||||
* circumstances, unlike <code>ubidi_getLevelAt()</code>.
|
||||
*
|
||||
* @param pBiDi is the paragraph or line <code>UBiDi</code> object.
|
||||
*
|
||||
* @param pErrorCode must be a valid pointer to an error code value,
|
||||
* which must not indicate a failure before the function call.
|
||||
*
|
||||
* @return The levels array for the text,
|
||||
* or <code>NULL</code> if an error occurs.
|
||||
*
|
||||
* @see UBiDiLevel
|
||||
*/
|
||||
CAPI const UBiDiLevel * U_EXPORT2
|
||||
ubidi_getLevels(UBiDi *pBiDi, UErrorCode *pErrorCode);
|
||||
|
||||
/**
|
||||
* Get a logical run.
|
||||
* This function returns information about a run and is used
|
||||
* to retrieve runs in logical order.<p>
|
||||
* This is especially useful for line-breaking on a paragraph.
|
||||
*
|
||||
* @param pBiDi is the paragraph or line <code>UBiDi</code> object.
|
||||
*
|
||||
* @param logicalStart is the first character of the run.
|
||||
*
|
||||
* @param pLogicalLimit will receive the limit of the run.
|
||||
* The l-value that you point to here may be the
|
||||
* same expression (variable) as the one for
|
||||
* <code>logicalStart</code>.
|
||||
* This pointer can be <code>NULL</code> if this
|
||||
* value is not necessary.
|
||||
*
|
||||
* @param pLevel will receive the level of the run.
|
||||
* This pointer can be <code>NULL</code> if this
|
||||
* value is not necessary.
|
||||
*/
|
||||
CAPI void U_EXPORT2
|
||||
ubidi_getLogicalRun(const UBiDi *pBiDi, UTextOffset logicalStart,
|
||||
UTextOffset *pLogicalLimit, UBiDiLevel *pLevel);
|
||||
|
||||
/**
|
||||
* Get the number of runs.
|
||||
* This function may invoke the actual reordering on the
|
||||
* <code>UBiDi</code> object, after <code>ubidi_setPara()</code>
|
||||
* may have resolved only the levels of the text. Therefore,
|
||||
* <code>ubidi_countRuns()</code> may have to allocate memory,
|
||||
* and may fail doing so.
|
||||
*
|
||||
* @param pBiDi is the paragraph or line <code>UBiDi</code> object.
|
||||
*
|
||||
* @param pErrorCode must be a valid pointer to an error code value,
|
||||
* which must not indicate a failure before the function call.
|
||||
*
|
||||
* @return The number of runs.
|
||||
*/
|
||||
CAPI UTextOffset U_EXPORT2
|
||||
ubidi_countRuns(UBiDi *pBiDi, UErrorCode *pErrorCode);
|
||||
|
||||
/**
|
||||
* Get one run's logical start, length, and directionality,
|
||||
* which can be 0 for LTR or 1 for RTL.
|
||||
* In an RTL run, the character at the logical start is
|
||||
* visually on the right of the displayed run.
|
||||
* The length is the number of characters in the run.<p>
|
||||
* <code>ubidi_countRuns()</code> should be called
|
||||
* before the runs are retrieved.
|
||||
*
|
||||
* @param pBiDi is the paragraph or line <code>UBiDi</code> object.
|
||||
*
|
||||
* @param runIndex is the number of the run in visual order, in the
|
||||
* range <code>[0..ubidi_countRuns(pBiDi)-1]</code>.
|
||||
*
|
||||
* @param pLogicalStart is the first logical character index in the text.
|
||||
* The pointer may be <code>NULL</code> if this index is not needed.
|
||||
*
|
||||
* @param pLength is the number of characters (at least one) in the run.
|
||||
* The pointer may be <code>NULL</code> if this is not needed.
|
||||
*
|
||||
* @return the directionality of the run,
|
||||
* <code>UBIDI_LTR==0</code> or <code>UBIDI_RTL==1</code>,
|
||||
* never <code>UBIDI_MIXED</code>.
|
||||
*
|
||||
* @see ubidi_countRuns
|
||||
*
|
||||
* Example:
|
||||
* <pre>
|
||||
* UTextOffset i, count=ubidi_countRuns(pBiDi),
|
||||
* logicalStart, visualIndex=0, length;
|
||||
* for(i=0; i<count; ++i) {
|
||||
* if(UBIDI_LTR==ubidi_getVisualRun(pBiDi, i, &logicalStart, &length)) {
|
||||
* do { // LTR
|
||||
* show_char(text[logicalStart++], visualIndex++);
|
||||
* } while(--length>0);
|
||||
* } else {
|
||||
* logicalStart+=length; // logicalLimit
|
||||
* do { // RTL
|
||||
* show_char(text[--logicalStart], visualIndex++);
|
||||
* } while(--length>0);
|
||||
* }
|
||||
* }
|
||||
* </pre>
|
||||
*
|
||||
* Note that in right-to-left runs, code like this places
|
||||
* modifier letters before base characters and second surrogates
|
||||
* before first ones.
|
||||
*/
|
||||
CAPI UBiDiDirection U_EXPORT2
|
||||
ubidi_getVisualRun(UBiDi *pBiDi, UTextOffset runIndex,
|
||||
UTextOffset *pLogicalStart, UTextOffset *pLength);
|
||||
|
||||
/**
|
||||
* Get the visual position from a logical text position.
|
||||
* If such a mapping is used many times on the same
|
||||
* <code>UBiDi</code> object, then calling
|
||||
* <code>ubidi_getLogicalMap()</code> is more efficient.<p>
|
||||
*
|
||||
* Note that in right-to-left runs, this mapping places
|
||||
* modifier letters before base characters and second surrogates
|
||||
* before first ones.
|
||||
*
|
||||
* @param pBiDi is the paragraph or line <code>UBiDi</code> object.
|
||||
*
|
||||
* @param logicalIndex is the index of a character in the text.
|
||||
*
|
||||
* @param pErrorCode must be a valid pointer to an error code value,
|
||||
* which must not indicate a failure before the function call.
|
||||
*
|
||||
* @return The visual position of this character.
|
||||
*
|
||||
* @see ubidi_getLogicalMap
|
||||
* @see ubidi_getLogicalIndex
|
||||
*/
|
||||
CAPI UTextOffset U_EXPORT2
|
||||
ubidi_getVisualIndex(UBiDi *pBiDi, UTextOffset logicalIndex, UErrorCode *pErrorCode);
|
||||
|
||||
/**
|
||||
* Get the logical text position from a visual position.
|
||||
* If such a mapping is used many times on the same
|
||||
* <code>UBiDi</code> object, then calling
|
||||
* <code>ubidi_getVisualMap()</code> is more efficient.<p>
|
||||
*
|
||||
* This is the inverse function to <code>ubidi_getVisualIndex()</code>.
|
||||
*
|
||||
* @param pBiDi is the paragraph or line <code>UBiDi</code> object.
|
||||
*
|
||||
* @param visualIndex is the visual position of a character.
|
||||
*
|
||||
* @param pErrorCode must be a valid pointer to an error code value,
|
||||
* which must not indicate a failure before the function call.
|
||||
*
|
||||
* @return The index of this character in the text.
|
||||
*
|
||||
* @see ubidi_getVisualMap
|
||||
* @see ubidi_getVisualIndex
|
||||
*/
|
||||
CAPI UTextOffset U_EXPORT2
|
||||
ubidi_getLogicalIndex(UBiDi *pBiDi, UTextOffset visualIndex, UErrorCode *pErrorCode);
|
||||
|
||||
/**
|
||||
* Get a logical-to-visual index map (array) for the characters in the UBiDi
|
||||
* (paragraph or line) object.
|
||||
*
|
||||
* @param pBiDi is the paragraph or line <code>UBiDi</code> object.
|
||||
*
|
||||
* @param indexMap is a pointer to an array of <code>ubidi_getLength()</code>
|
||||
* indexes which will reflect the reordering of the characters.
|
||||
* The array does not need to be initialized.<p>
|
||||
* The index map will result in <code>indexMap[logicalIndex]==visualIndex</code>.<p>
|
||||
*
|
||||
* @param pErrorCode must be a valid pointer to an error code value,
|
||||
* which must not indicate a failure before the function call.
|
||||
*
|
||||
* @see ubidi_getVisualMap
|
||||
* @see ubidi_getVisualIndex
|
||||
*/
|
||||
CAPI void U_EXPORT2
|
||||
ubidi_getLogicalMap(UBiDi *pBiDi, UTextOffset *indexMap, UErrorCode *pErrorCode);
|
||||
|
||||
/**
|
||||
* Get a visual-to-logical index map (array) for the characters in the UBiDi
|
||||
* (paragraph or line) object.
|
||||
*
|
||||
* @param pBiDi is the paragraph or line <code>UBiDi</code> object.
|
||||
*
|
||||
* @param indexMap is a pointer to an array of <code>ubidi_getLength()</code>
|
||||
* indexes which will reflect the reordering of the characters.
|
||||
* The array does not need to be initialized.<p>
|
||||
* The index map will result in <code>indexMap[visualIndex]==logicalIndex</code>.<p>
|
||||
*
|
||||
* @param pErrorCode must be a valid pointer to an error code value,
|
||||
* which must not indicate a failure before the function call.
|
||||
*
|
||||
* @see ubidi_getLogicalMap
|
||||
* @see ubidi_getLogicalIndex
|
||||
*/
|
||||
CAPI void U_EXPORT2
|
||||
ubidi_getVisualMap(UBiDi *pBiDi, UTextOffset *indexMap, UErrorCode *pErrorCode);
|
||||
|
||||
/**
|
||||
* This is a convenience function that does not use a UBiDi object.
|
||||
* It is intended to be used for when an application has determined the levels
|
||||
* of objects (character sequences) and just needs to have them reordered (L2).
|
||||
* This is equivalent to using <code>ubidi_getLogicalMap</code> on a
|
||||
* <code>UBiDi</code> object.
|
||||
*
|
||||
* @param levels is an array with <code>length</code> levels that have been determined by
|
||||
* the application.
|
||||
*
|
||||
* @param length is the number of levels in the array, or, semantically,
|
||||
* the number of objects to be reordered.
|
||||
* It must be <code>length>0</code>.
|
||||
*
|
||||
* @param indexMap is a pointer to an array of <code>length</code>
|
||||
* indexes which will reflect the reordering of the characters.
|
||||
* The array does not need to be initialized.<p>
|
||||
* The index map will result in <code>indexMap[logicalIndex]==visualIndex</code>.
|
||||
*/
|
||||
CAPI void U_EXPORT2
|
||||
ubidi_reorderLogical(const UBiDiLevel *levels, UTextOffset length, UTextOffset *indexMap);
|
||||
|
||||
/**
|
||||
* This is a convenience function that does not use a UBiDi object.
|
||||
* It is intended to be used for when an application has determined the levels
|
||||
* of objects (character sequences) and just needs to have them reordered (L2).
|
||||
* This is equivalent to using <code>ubidi_getVisualMap</code> on a
|
||||
* <code>UBiDi</code> object.
|
||||
*
|
||||
* @param levels is an array with <code>length</code> levels that have been determined by
|
||||
* the application.
|
||||
*
|
||||
* @param length is the number of levels in the array, or, semantically,
|
||||
* the number of objects to be reordered.
|
||||
* It must be <code>length>0</code>.
|
||||
*
|
||||
* @param indexMap is a pointer to an array of <code>length</code>
|
||||
* indexes which will reflect the reordering of the characters.
|
||||
* The array does not need to be initialized.<p>
|
||||
* The index map will result in <code>indexMap[visualIndex]==logicalIndex</code>.
|
||||
*/
|
||||
CAPI void U_EXPORT2
|
||||
ubidi_reorderVisual(const UBiDiLevel *levels, UTextOffset length, UTextOffset *indexMap);
|
||||
|
||||
/**
|
||||
* Invert an index map.
|
||||
* The one-to-one index mapping of the first map is inverted and written to
|
||||
* the second one.
|
||||
*
|
||||
* @param srcMap is an array with <code>length</code> indexes
|
||||
* which define the original mapping.
|
||||
*
|
||||
* @param destMap is an array with <code>length</code> indexes
|
||||
* which will be filled with the inverse mapping.
|
||||
*
|
||||
* @param length is the length of each array.
|
||||
*/
|
||||
CAPI void U_EXPORT2
|
||||
ubidi_invertMap(const UTextOffset *srcMap, UTextOffset *destMap, UTextOffset length);
|
||||
|
||||
/**
|
||||
* @name Sample code for the ICU BiDi API
|
||||
*
|
||||
* <h2>Rendering a paragraph with the ICU BiDi API</h2>
|
||||
*
|
||||
* This is (hypothetical) sample code that illustrates
|
||||
* how the ICU BiDi API could be used to render a paragraph of text.
|
||||
* Rendering code depends highly on the graphics system,
|
||||
* therefore this sample code must make a lot of assumptions,
|
||||
* which may or may not match any existing graphics system's properties.
|
||||
*
|
||||
* <p>The basic assumptions are:</p>
|
||||
* <ul>
|
||||
* <li>Rendering is done from left to right on a horizontal line.</li>
|
||||
* <li>A run of single-style, unidirectional text can be rendered at once.</li>
|
||||
* <li>Such a run of text is passed to the graphics system with
|
||||
* characters (code units) in logical order.</li>
|
||||
* <li>The line-breaking algorithm is very complicated
|
||||
* and Locale-dependent -
|
||||
* and therefore its implementation omitted from this sample code.</li>
|
||||
* </ul>
|
||||
*
|
||||
* <pre>
|
||||
* #include "ubidi.h"
|
||||
*
|
||||
* typedef enum {
|
||||
* styleNormal=0, styleSelected=1,
|
||||
* styleBold=2, styleItalics=4,
|
||||
* styleSuper=8, styleSub=16
|
||||
* } Style;
|
||||
*
|
||||
* typedef struct { UTextOffset limit; Style style; } StyleRun;
|
||||
*
|
||||
* int getTextWidth(const UChar *text, UTextOffset start, UTextOffset limit,
|
||||
* const StyleRun *styleRuns, int styleRunCount);
|
||||
*
|
||||
* // set *pLimit and *pStyleRunLimit for a line
|
||||
* // from text[start] and from styleRuns[styleRunStart]
|
||||
* // using ubidi_getLogicalRun(para, ...)
|
||||
* void getLineBreak(const UChar *text, UTextOffset start, UTextOffset *pLimit,
|
||||
* UBiDi *para,
|
||||
* const StyleRun *styleRuns, int styleRunStart, int *pStyleRunLimit,
|
||||
* int *pLineWidth);
|
||||
*
|
||||
* // render runs on a line sequentially, always from left to right
|
||||
*
|
||||
* // prepare rendering a new line
|
||||
* void startLine(UBiDiDirection textDirection, int lineWidth);
|
||||
*
|
||||
* // render a run of text and advance to the right by the run width
|
||||
* // the text[start..limit-1] is always in logical order
|
||||
* void renderRun(const UChar *text, UTextOffset start, UTextOffset limit,
|
||||
* UBiDiDirection textDirection, Style style);
|
||||
*
|
||||
* // We could compute a cross-product
|
||||
* // from the style runs with the directional runs
|
||||
* // and then reorder it.
|
||||
* // Instead, here we iterate over each run type
|
||||
* // and render the intersections -
|
||||
* // with shortcuts in simple (and common) cases.
|
||||
* // renderParagraph() is the main function.
|
||||
*
|
||||
* // render a directional run with
|
||||
* // (possibly) multiple style runs intersecting with it
|
||||
* void renderDirectionalRun(const UChar *text,
|
||||
* UTextOffset start, UTextOffset limit,
|
||||
* UBiDiDirection direction,
|
||||
* const StyleRun *styleRuns, int styleRunCount) {
|
||||
* int i;
|
||||
*
|
||||
* // iterate over style runs
|
||||
* if(direction==UBIDI_LTR) {
|
||||
* int styleLimit;
|
||||
*
|
||||
* for(i=0; i<styleRunCount; ++i) {
|
||||
* styleLimit=styleRun[i].limit;
|
||||
* if(start<styleLimit) {
|
||||
* if(styleLimit>limit) { styleLimit=limit; }
|
||||
* renderRun(text, start, styleLimit,
|
||||
* direction, styleRun[i].style);
|
||||
* if(styleLimit==limit) { break; }
|
||||
* start=styleLimit;
|
||||
* }
|
||||
* }
|
||||
* } else {
|
||||
* int styleStart;
|
||||
*
|
||||
* for(i=styleRunCount-1; i>=0; --i) {
|
||||
* if(i>0) {
|
||||
* styleStart=styleRun[i-1].limit;
|
||||
* } else {
|
||||
* styleStart=0;
|
||||
* }
|
||||
* if(limit>=styleStart) {
|
||||
* if(styleStart<start) { styleStart=start; }
|
||||
* renderRun(text, styleStart, limit,
|
||||
* direction, styleRun[i].style);
|
||||
* if(styleStart==start) { break; }
|
||||
* limit=styleStart;
|
||||
* }
|
||||
* }
|
||||
* }
|
||||
* }
|
||||
*
|
||||
* // the line object represents text[start..limit-1]
|
||||
* void renderLine(UBiDi *line, const UChar *text,
|
||||
* UTextOffset start, UTextOffset limit,
|
||||
* const StyleRun *styleRuns, int styleRunCount) {
|
||||
* UBiDiDirection direction=ubidi_getDirection(line);
|
||||
* if(direction!=UBIDI_MIXED) {
|
||||
* // unidirectional
|
||||
* if(styleRunCount<=1) {
|
||||
* renderRun(text, start, limit, direction, styleRuns[0].style);
|
||||
* } else {
|
||||
* renderDirectionalRun(text, start, limit,
|
||||
* direction, styleRuns, styleRunCount);
|
||||
* }
|
||||
* } else {
|
||||
* // mixed-directional
|
||||
* UTextOffset count, i, length;
|
||||
* UBiDiLevel level;
|
||||
*
|
||||
* count=ubidi_countRuns(para, pErrorCode);
|
||||
* if(SUCCESS(*pErrorCode)) {
|
||||
* if(styleRunCount<=1) {
|
||||
* Style style=styleRuns[0].style;
|
||||
*
|
||||
* // iterate over directional runs
|
||||
* for(i=0; i<count; ++i) {
|
||||
* direction=ubidi_getVisualRun(para, i, &start, &length);
|
||||
* renderRun(text, start, start+length, direction, style);
|
||||
* }
|
||||
* } else {
|
||||
* UTextOffset j;
|
||||
*
|
||||
* // iterate over both directional and style runs
|
||||
* for(i=0; i<count; ++i) {
|
||||
* direction=ubidi_getVisualRun(line, i, &start, &length);
|
||||
* renderDirectionalRun(text, start, start+length,
|
||||
* direction, styleRuns, styleRunCount);
|
||||
* }
|
||||
* }
|
||||
* }
|
||||
* }
|
||||
* }
|
||||
*
|
||||
* void renderParagraph(const UChar *text, UTextOffset length,
|
||||
* UBiDiDirection textDirection,
|
||||
* const StyleRun *styleRuns, int styleRunCount,
|
||||
* int lineWidth,
|
||||
* UErrorCode *pErrorCode) {
|
||||
* UBiDi *para;
|
||||
*
|
||||
* if(pErrorCode==NULL || FAILURE(*pErrorCode) || length<=0) {
|
||||
* return;
|
||||
* }
|
||||
*
|
||||
* para=ubidi_openSized(length, 0, pErrorCode);
|
||||
* if(para==NULL) { return; }
|
||||
*
|
||||
* ubidi_setPara(para, text, length,
|
||||
* textDirection ? UBIDI_DEFAULT_RTL : UBIDI_DEFAULT_LTR,
|
||||
* NULL, pErrorCode);
|
||||
* if(SUCCESS(*pErrorCode)) {
|
||||
* UBiDiLevel paraLevel=1&ubidi_getParaLevel(para);
|
||||
* StyleRun styleRun={ length, styleNormal };
|
||||
* int width;
|
||||
*
|
||||
* if(styleRuns==NULL || styleRunCount<=0) {
|
||||
* styleRunCount=1;
|
||||
* styleRuns=&styleRun;
|
||||
* }
|
||||
*
|
||||
* // assume styleRuns[styleRunCount-1].limit>=length
|
||||
*
|
||||
* width=getTextWidth(text, 0, length, styleRuns, styleRunCount);
|
||||
* if(width<=lineWidth) {
|
||||
* // everything fits onto one line
|
||||
*
|
||||
* // prepare rendering a new line from either left or right
|
||||
* startLine(paraLevel, width);
|
||||
*
|
||||
* renderLine(para, text, 0, length,
|
||||
* styleRuns, styleRunCount);
|
||||
* } else {
|
||||
* UBiDi *line;
|
||||
*
|
||||
* // we need to render several lines
|
||||
* line=ubidi_openSized(length, 0, pErrorCode);
|
||||
* if(line!=NULL) {
|
||||
* UTextOffset start=0, limit;
|
||||
* int styleRunStart=0, styleRunLimit;
|
||||
*
|
||||
* for(;;) {
|
||||
* limit=length;
|
||||
* styleRunLimit=styleRunCount;
|
||||
* getLineBreak(text, start, &limit, para,
|
||||
* styleRuns, styleRunStart, &styleRunLimit,
|
||||
* &width);
|
||||
* ubidi_setLine(para, start, limit, line, pErrorCode);
|
||||
* if(SUCCESS(*pErrorCode)) {
|
||||
* // prepare rendering a new line
|
||||
* // from either left or right
|
||||
* startLine(paraLevel, width);
|
||||
*
|
||||
* renderLine(line, text, start, limit,
|
||||
* styleRuns+styleRunStart,
|
||||
* styleRunLimit-styleRunStart);
|
||||
* }
|
||||
* if(limit==length) { break; }
|
||||
* start=limit;
|
||||
* styleRunStart=styleRunLimit-1;
|
||||
* if(start>=styleRuns[styleRunStart].limit) {
|
||||
* ++styleRunStart;
|
||||
* }
|
||||
* }
|
||||
*
|
||||
* ubidi_close(line);
|
||||
* }
|
||||
* }
|
||||
* }
|
||||
*
|
||||
* ubidi_close(para);
|
||||
* }
|
||||
* </pre>
|
||||
*/
|
||||
BIDI_SAMPLE_CODE
|
||||
/*@{*/
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif
|
||||
220
source/common/ubidiimp.h
Normal file
220
source/common/ubidiimp.h
Normal file
|
|
@ -0,0 +1,220 @@
|
|||
/*
|
||||
*******************************************************************************
|
||||
* *
|
||||
* COPYRIGHT: *
|
||||
* (C) Copyright International Business Machines Corporation, 1999 *
|
||||
* Licensed Material - Program-Property of IBM - All Rights Reserved. *
|
||||
* US Government Users Restricted Rights - Use, duplication, or disclosure *
|
||||
* restricted by GSA ADP Schedule Contract with IBM Corp. *
|
||||
* *
|
||||
*******************************************************************************
|
||||
* 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 "utypes.h"
|
||||
#include "uchar.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)
|
||||
|
||||
/* to avoid some conditional statements, use tiny constant arrays */
|
||||
static Flags flagLR[2]={ DIRPROP_FLAG(L), DIRPROP_FLAG(R) };
|
||||
static Flags flagE[2]={ DIRPROP_FLAG(LRE), DIRPROP_FLAG(RLE) };
|
||||
static 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]
|
||||
|
||||
/* 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)==0xfe)
|
||||
|
||||
/* handle surrogate pairs --------------------------------------------------- */
|
||||
|
||||
#define IS_FIRST_SURROGATE(uchar) (((uchar)&0xfc00)==0xd800)
|
||||
#define IS_SECOND_SURROGATE(uchar) (((uchar)&0xfc00)==0xdc00)
|
||||
|
||||
/* get the UTF-32 value directly from the surrogate pseudo-characters */
|
||||
#define SURROGATE_OFFSET ((0xd800<<10UL)+0xdc00-0x10000)
|
||||
#define GET_UTF_32(first, second) (((first)<<10UL)+(second)-SURROGATE_OFFSET)
|
||||
|
||||
/* Run structure for reordering --------------------------------------------- */
|
||||
|
||||
typedef struct Run {
|
||||
UTextOffset 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|((uint32_t)level<<31))
|
||||
#define ADD_ODD_BIT_FROM_LEVEL(x, level) ((x)|=((uint32_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)
|
||||
|
||||
/* UBiDi structure ----------------------------------------------------------- */
|
||||
|
||||
struct UBiDi {
|
||||
/* length of the current text */
|
||||
UTextOffset length;
|
||||
|
||||
/* memory sizes in bytes */
|
||||
UTextOffset dirPropsSize, levelsSize, runsSize;
|
||||
|
||||
/* allocated memory */
|
||||
DirProp *dirPropsMemory;
|
||||
UBiDiLevel *levelsMemory;
|
||||
Run *runsMemory;
|
||||
|
||||
/* indicators for whether memory may be allocated after ubidi_open() */
|
||||
bool_t mayAllocateText, mayAllocateRuns;
|
||||
|
||||
/* arrays with one value per text-character */
|
||||
const DirProp *dirProps;
|
||||
UBiDiLevel *levels;
|
||||
|
||||
/* the paragraph level */
|
||||
UBiDiLevel paraLevel;
|
||||
|
||||
/* flags is a bit set for which directional properties are in the text */
|
||||
Flags flags;
|
||||
|
||||
/* the overall paragraph or line directionality - see UBiDiDirection */
|
||||
UBiDiDirection direction;
|
||||
|
||||
/* characters after trailingWSStart are WS and are */
|
||||
/* implicitly at the paraLevel (rule (L1)) - levels may not reflect that */
|
||||
UTextOffset trailingWSStart;
|
||||
|
||||
/* fields for line reordering */
|
||||
UTextOffset 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];
|
||||
};
|
||||
|
||||
/* helper function to (re)allocate memory if allowed */
|
||||
extern bool_t
|
||||
getMemory(void **pMemory, UTextOffset *pSize, bool_t mayAllocate, UTextOffset sizeNeeded);
|
||||
|
||||
/* helper macros for each allocated array in UBiDi */
|
||||
#define getDirPropsMemory(pBiDi, length) \
|
||||
getMemory((void **)&(pBiDi)->dirPropsMemory, &(pBiDi)->dirPropsSize, \
|
||||
(pBiDi)->mayAllocateText, (length))
|
||||
|
||||
#define getLevelsMemory(pBiDi, length) \
|
||||
getMemory((void **)&(pBiDi)->levelsMemory, &(pBiDi)->levelsSize, \
|
||||
(pBiDi)->mayAllocateText, (length))
|
||||
|
||||
#define getRunsMemory(pBiDi, length) \
|
||||
getMemory((void **)&(pBiDi)->runsMemory, &(pBiDi)->runsSize, \
|
||||
(pBiDi)->mayAllocateRuns, (length)*sizeof(Run))
|
||||
|
||||
/* additional macros used by ubidi_open() - always allow allocation */
|
||||
#define getInitialDirPropsMemory(pBiDi, length) \
|
||||
getMemory((void **)&(pBiDi)->dirPropsMemory, &(pBiDi)->dirPropsSize, \
|
||||
TRUE, (length))
|
||||
|
||||
#define getInitialLevelsMemory(pBiDi, length) \
|
||||
getMemory((void **)&(pBiDi)->levelsMemory, &(pBiDi)->levelsSize, \
|
||||
TRUE, (length))
|
||||
|
||||
#define getInitialRunsMemory(pBiDi, length) \
|
||||
getMemory((void **)&(pBiDi)->runsMemory, &(pBiDi)->runsSize, \
|
||||
TRUE, (length)*sizeof(Run))
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
980
source/common/ubidiln.c
Normal file
980
source/common/ubidiln.c
Normal file
|
|
@ -0,0 +1,980 @@
|
|||
/*
|
||||
*******************************************************************************
|
||||
* *
|
||||
* COPYRIGHT: *
|
||||
* (C) Copyright International Business Machines Corporation, 1999 *
|
||||
* Licensed Material - Program-Property of IBM - All Rights Reserved. *
|
||||
* US Government Users Restricted Rights - Use, duplication, or disclosure *
|
||||
* restricted by GSA ADP Schedule Contract with IBM Corp. *
|
||||
* *
|
||||
*******************************************************************************
|
||||
* file name: ubidiln.c
|
||||
* encoding: US-ASCII
|
||||
* tab size: 8 (not used)
|
||||
* indentation:4
|
||||
*
|
||||
* created on: 1999aug06
|
||||
* created by: Markus W. Scherer
|
||||
*/
|
||||
|
||||
/* set import/export definitions */
|
||||
#ifndef U_COMMON_IMPLEMENTATION
|
||||
# define U_COMMON_IMPLEMENTATION
|
||||
#endif
|
||||
|
||||
#include "cmemory.h"
|
||||
#include "utypes.h"
|
||||
#include "ustring.h"
|
||||
#include "uchar.h"
|
||||
#include "ubidi.h"
|
||||
#include "ubidiimp.h"
|
||||
|
||||
/*
|
||||
* General remarks about the functions in this file:
|
||||
*
|
||||
* These functions deal with the aspects of potentially mixed-directional
|
||||
* text in a single paragraph or in a line of a single paragraph
|
||||
* which has already been processed according to
|
||||
* the Unicode 3.0 BiDi algorithm as defined in
|
||||
* http://www.unicode.org/unicode/reports/tr9/ , version 5,
|
||||
* also described in The Unicode Standard, Version 3.0 .
|
||||
*
|
||||
* This means that there is a UBiDi object with a levels
|
||||
* and a dirProps array.
|
||||
* paraLevel and direction are also set.
|
||||
* Only if the length of the text is zero, then levels==dirProps==NULL.
|
||||
*
|
||||
* The overall directionality of the paragraph
|
||||
* or line is used to bypass the reordering steps if possible.
|
||||
* Even purely RTL text does not need reordering there because
|
||||
* the ubidi_getLogical/VisualIndex() functions can compute the
|
||||
* index on the fly in such a case.
|
||||
*
|
||||
* The implementation of the access to same-level-runs and of the reordering
|
||||
* do attempt to provide better performance and less memory usage compared to
|
||||
* a direct implementation of especially rule (L2) with an array of
|
||||
* one (32-bit) integer per text character.
|
||||
*
|
||||
* Here, the levels array is scanned as soon as necessary, and a vector of
|
||||
* same-level-runs is created. Reordering then is done on this vector.
|
||||
* For each run of text positions that were resolved to the same level,
|
||||
* only 8 bytes are stored: the first text position of the run and the visual
|
||||
* position behind the run after reordering.
|
||||
* One sign bit is used to hold the directionality of the run.
|
||||
* This is inefficient if there are many very short runs. If the average run
|
||||
* length is <2, then this uses more memory.
|
||||
*
|
||||
* In a further attempt to save memory, the levels array is never changed
|
||||
* after all the resolution rules (Xn, Wn, Nn, In).
|
||||
* Many functions have to consider the field trailingWSStart:
|
||||
* if it is less than length, then there is an implicit trailing run
|
||||
* at the paraLevel,
|
||||
* which is not reflected in the levels array.
|
||||
* This allows a line UBiDi object to use the same levels array as
|
||||
* its paragraph parent object.
|
||||
*
|
||||
* When a UBiDi object is created for a line of a paragraph, then the
|
||||
* paragraph's levels and dirProps arrays are reused by way of setting
|
||||
* a pointer into them, not by copying. This again saves memory and forbids to
|
||||
* change the now shared levels for (L1).
|
||||
*/
|
||||
|
||||
/* prototypes --------------------------------------------------------------- */
|
||||
|
||||
static void
|
||||
setTrailingWSStart(UBiDi *pBiDi);
|
||||
|
||||
static bool_t
|
||||
getRuns(UBiDi *pBiDi);
|
||||
|
||||
static void
|
||||
getSingleRun(UBiDi *pBiDi, UBiDiLevel level);
|
||||
|
||||
static void
|
||||
reorderLine(UBiDi *pBiDi, UBiDiLevel minLevel, UBiDiLevel maxLevel);
|
||||
|
||||
static bool_t
|
||||
prepareReorder(const UBiDiLevel *levels, UTextOffset length,
|
||||
UTextOffset *indexMap,
|
||||
UBiDiLevel *pMinLevel, UBiDiLevel *pMaxLevel);
|
||||
|
||||
/* ubidi_setLine ------------------------------------------------------------ */
|
||||
|
||||
CAPI void U_EXPORT2
|
||||
ubidi_setLine(const UBiDi *pParaBiDi,
|
||||
UTextOffset start, UTextOffset limit,
|
||||
UBiDi *pLineBiDi,
|
||||
UErrorCode *pErrorCode) {
|
||||
UTextOffset length;
|
||||
|
||||
/* check the argument values */
|
||||
if(pErrorCode==NULL || FAILURE(*pErrorCode)) {
|
||||
return;
|
||||
} else if(pParaBiDi==NULL ||
|
||||
start<0 || start>limit || limit>pParaBiDi->length ||
|
||||
pLineBiDi==NULL
|
||||
) {
|
||||
*pErrorCode=ILLEGAL_ARGUMENT_ERROR;
|
||||
return;
|
||||
}
|
||||
|
||||
/* set the values in pLineBiDi from its pParaBiDi parent */
|
||||
length=pLineBiDi->length=limit-start;
|
||||
pLineBiDi->paraLevel=pParaBiDi->paraLevel;
|
||||
|
||||
pLineBiDi->runs=NULL;
|
||||
pLineBiDi->flags=0;
|
||||
|
||||
if(length>0) {
|
||||
pLineBiDi->dirProps=pParaBiDi->dirProps+start;
|
||||
pLineBiDi->levels=pParaBiDi->levels+start;
|
||||
pLineBiDi->runCount=-1;
|
||||
|
||||
if(pParaBiDi->direction!=UBIDI_MIXED) {
|
||||
/* the parent is already trivial */
|
||||
pLineBiDi->direction=pParaBiDi->direction;
|
||||
|
||||
/*
|
||||
* The parent's levels are all either
|
||||
* implicitly or explicitly ==paraLevel;
|
||||
* do the same here.
|
||||
*/
|
||||
if(pParaBiDi->trailingWSStart<=start) {
|
||||
pLineBiDi->trailingWSStart=0;
|
||||
} else if(pParaBiDi->trailingWSStart<limit) {
|
||||
pLineBiDi->trailingWSStart=pParaBiDi->trailingWSStart-start;
|
||||
} else {
|
||||
pLineBiDi->trailingWSStart=length;
|
||||
}
|
||||
} else {
|
||||
const UBiDiLevel *levels=pLineBiDi->levels;
|
||||
UTextOffset i, trailingWSStart;
|
||||
UBiDiLevel level;
|
||||
Flags flags=0;
|
||||
|
||||
setTrailingWSStart(pLineBiDi);
|
||||
trailingWSStart=pLineBiDi->trailingWSStart;
|
||||
|
||||
/* recalculate pLineBiDi->direction */
|
||||
if(trailingWSStart==0) {
|
||||
/* all levels are at paraLevel */
|
||||
pLineBiDi->direction=(UBiDiDirection)(pLineBiDi->paraLevel&1);
|
||||
} else {
|
||||
/* get the level of the first character */
|
||||
level=levels[0]&1;
|
||||
|
||||
/* if there is anything of a different level, then the line is mixed */
|
||||
if(trailingWSStart<length && (pLineBiDi->paraLevel&1)!=level) {
|
||||
/* the trailing WS is at paraLevel, which differs from levels[0] */
|
||||
pLineBiDi->direction=UBIDI_MIXED;
|
||||
} else {
|
||||
/* see if levels[1..trailingWSStart-1] have the same direction as levels[0] and paraLevel */
|
||||
i=1;
|
||||
for(;;) {
|
||||
if(i==trailingWSStart) {
|
||||
/* the direction values match those in level */
|
||||
pLineBiDi->direction=(UBiDiDirection)level;
|
||||
break;
|
||||
} else if((levels[i]&1)!=level) {
|
||||
pLineBiDi->direction=UBIDI_MIXED;
|
||||
break;
|
||||
}
|
||||
++i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
switch(pLineBiDi->direction) {
|
||||
case UBIDI_LTR:
|
||||
/* make sure paraLevel is even */
|
||||
pLineBiDi->paraLevel=(pLineBiDi->paraLevel+1)&~1;
|
||||
|
||||
/* all levels are implicitly at paraLevel (important for ubidi_getLevels()) */
|
||||
pLineBiDi->trailingWSStart=0;
|
||||
break;
|
||||
case UBIDI_RTL:
|
||||
/* make sure paraLevel is odd */
|
||||
pLineBiDi->paraLevel|=1;
|
||||
|
||||
/* all levels are implicitly at paraLevel (important for ubidi_getLevels()) */
|
||||
pLineBiDi->trailingWSStart=0;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
/* create an object for a zero-length line */
|
||||
pLineBiDi->direction=pLineBiDi->paraLevel&1 ? UBIDI_RTL : UBIDI_LTR;
|
||||
pLineBiDi->trailingWSStart=pLineBiDi->runCount=0;
|
||||
|
||||
pLineBiDi->dirProps=NULL;
|
||||
pLineBiDi->levels=NULL;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
CAPI UBiDiLevel U_EXPORT2
|
||||
ubidi_getLevelAt(const UBiDi *pBiDi, UTextOffset charIndex) {
|
||||
/* return paraLevel if in the trailing WS run, otherwise the real level */
|
||||
if(pBiDi==NULL || charIndex<0 || pBiDi->length<=charIndex) {
|
||||
return 0;
|
||||
} else if(pBiDi->direction!=UBIDI_MIXED || charIndex>=pBiDi->trailingWSStart) {
|
||||
return pBiDi->paraLevel;
|
||||
} else {
|
||||
return pBiDi->levels[charIndex];
|
||||
}
|
||||
}
|
||||
|
||||
CAPI const UBiDiLevel * U_EXPORT2
|
||||
ubidi_getLevels(UBiDi *pBiDi, UErrorCode *pErrorCode) {
|
||||
UTextOffset start, length;
|
||||
|
||||
if(pErrorCode==NULL || FAILURE(*pErrorCode)) {
|
||||
return NULL;
|
||||
} else if(pBiDi==NULL || (length=pBiDi->length)<=0) {
|
||||
*pErrorCode=ILLEGAL_ARGUMENT_ERROR;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if((start=pBiDi->trailingWSStart)==length) {
|
||||
/* the current levels array reflects the WS run */
|
||||
return pBiDi->levels;
|
||||
}
|
||||
|
||||
/*
|
||||
* After the previous if(), we know that the levels array
|
||||
* has an implicit trailing WS run and therefore does not fully
|
||||
* reflect itself all the levels.
|
||||
* This must be a UBiDi object for a line, and
|
||||
* we need to create a new levels array.
|
||||
*/
|
||||
|
||||
if(getLevelsMemory(pBiDi, length)) {
|
||||
UBiDiLevel *levels=pBiDi->levelsMemory;
|
||||
|
||||
if(start>0 && levels!=pBiDi->levels) {
|
||||
icu_memcpy(levels, pBiDi->levels, start);
|
||||
}
|
||||
icu_memset(levels+start, pBiDi->paraLevel, length-start);
|
||||
|
||||
/* this new levels array is set for the line and reflects the WS run */
|
||||
pBiDi->trailingWSStart=length;
|
||||
return pBiDi->levels=levels;
|
||||
} else {
|
||||
/* out of memory */
|
||||
*pErrorCode=MEMORY_ALLOCATION_ERROR;
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
CAPI void U_EXPORT2
|
||||
ubidi_getLogicalRun(const UBiDi *pBiDi, UTextOffset logicalStart,
|
||||
UTextOffset *pLogicalLimit, UBiDiLevel *pLevel) {
|
||||
UTextOffset length;
|
||||
|
||||
if(pBiDi==NULL || logicalStart<0 || (length=pBiDi->length)<=logicalStart) {
|
||||
return;
|
||||
}
|
||||
|
||||
if(pBiDi->direction!=UBIDI_MIXED || logicalStart>=pBiDi->trailingWSStart) {
|
||||
if(pLogicalLimit!=NULL) {
|
||||
*pLogicalLimit=length;
|
||||
}
|
||||
if(pLevel!=NULL) {
|
||||
*pLevel=pBiDi->paraLevel;
|
||||
}
|
||||
} else {
|
||||
UBiDiLevel *levels=pBiDi->levels;
|
||||
UBiDiLevel level=levels[logicalStart];
|
||||
|
||||
/* search for the end of the run */
|
||||
length=pBiDi->trailingWSStart;
|
||||
while(++logicalStart<length && level==levels[logicalStart]) {}
|
||||
|
||||
if(pLogicalLimit!=NULL) {
|
||||
*pLogicalLimit=logicalStart;
|
||||
}
|
||||
if(pLevel!=NULL) {
|
||||
*pLevel=level;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* handle trailing WS (L1) -------------------------------------------------- */
|
||||
|
||||
/*
|
||||
* setTrailingWSStart() sets the start index for a trailing
|
||||
* run of WS in the line. This is necessary because we do not modify
|
||||
* the paragraph's levels array that we just point into.
|
||||
* Using trailingWSStart is another form of performing (L1).
|
||||
*
|
||||
* To make subsequent operations easier, we also include the run
|
||||
* before the WS if it is at the paraLevel - we merge the two here.
|
||||
*/
|
||||
static void
|
||||
setTrailingWSStart(UBiDi *pBiDi) {
|
||||
/* pBiDi->direction!=UBIDI_MIXED */
|
||||
|
||||
const DirProp *dirProps=pBiDi->dirProps;
|
||||
UBiDiLevel *levels=pBiDi->levels;
|
||||
UTextOffset start=pBiDi->length;
|
||||
UBiDiLevel paraLevel=pBiDi->paraLevel;
|
||||
|
||||
/* go backwards across all WS, BN, explicit codes */
|
||||
while(start>0 && DIRPROP_FLAG(dirProps[start-1])&MASK_WS) {
|
||||
--start;
|
||||
}
|
||||
|
||||
/* if the WS run can be merged with the previous run then do so here */
|
||||
while(start>0 && levels[start-1]==paraLevel) {
|
||||
--start;
|
||||
}
|
||||
|
||||
pBiDi->trailingWSStart=start;
|
||||
}
|
||||
|
||||
/* runs API functions ------------------------------------------------------- */
|
||||
|
||||
CAPI UTextOffset U_EXPORT2
|
||||
ubidi_countRuns(UBiDi *pBiDi, UErrorCode *pErrorCode) {
|
||||
if(pErrorCode==NULL || FAILURE(*pErrorCode)) {
|
||||
return -1;
|
||||
} else if(pBiDi==NULL || pBiDi->runCount<0 && !getRuns(pBiDi)) {
|
||||
*pErrorCode=MEMORY_ALLOCATION_ERROR;
|
||||
return -1;
|
||||
} else {
|
||||
return pBiDi->runCount;
|
||||
}
|
||||
}
|
||||
|
||||
CAPI UBiDiDirection U_EXPORT2
|
||||
ubidi_getVisualRun(UBiDi *pBiDi, UTextOffset runIndex,
|
||||
UTextOffset *pLogicalStart, UTextOffset *pLength) {
|
||||
if( pBiDi==NULL || runIndex<0 ||
|
||||
pBiDi->runCount==-1 && !getRuns(pBiDi) ||
|
||||
runIndex>=pBiDi->runCount
|
||||
) {
|
||||
return 0;
|
||||
} else {
|
||||
UTextOffset start=pBiDi->runs[runIndex].logicalStart;
|
||||
if(pLogicalStart!=NULL) {
|
||||
*pLogicalStart=GET_INDEX(start);
|
||||
}
|
||||
if(pLength!=NULL) {
|
||||
if(runIndex>0) {
|
||||
*pLength=pBiDi->runs[runIndex].visualLimit-
|
||||
pBiDi->runs[runIndex-1].visualLimit;
|
||||
} else {
|
||||
*pLength=pBiDi->runs[0].visualLimit;
|
||||
}
|
||||
}
|
||||
return (UBiDiDirection)GET_ODD_BIT(start);
|
||||
}
|
||||
}
|
||||
|
||||
/* compute the runs array --------------------------------------------------- */
|
||||
|
||||
/*
|
||||
* Compute the runs array from the levels array.
|
||||
* After getRuns() returns TRUE, runCount is guaranteed to be >0
|
||||
* and the runs are reordered.
|
||||
* Odd-level runs have visualStart on their visual right edge and
|
||||
* they progress visually to the left.
|
||||
*/
|
||||
static bool_t
|
||||
getRuns(UBiDi *pBiDi) {
|
||||
if(pBiDi->direction!=UBIDI_MIXED) {
|
||||
/* simple, single-run case - this covers length==0 */
|
||||
getSingleRun(pBiDi, pBiDi->paraLevel);
|
||||
} else /* UBIDI_MIXED, length>0 */ {
|
||||
/* mixed directionality */
|
||||
UTextOffset length=pBiDi->length, limit=length;
|
||||
|
||||
/*
|
||||
* If there are WS characters at the end of the line
|
||||
* and the run preceding them has a level different from
|
||||
* paraLevel, then they will form their own run at paraLevel (L1).
|
||||
* Count them separately.
|
||||
* We need some special treatment for this in order to not
|
||||
* modify the levels array which a line UBiDi object shares
|
||||
* with its paragraph parent and its other line siblings.
|
||||
* In other words, for the trailing WS, it may be
|
||||
* levels[]!=paraLevel but we have to treat it like it were so.
|
||||
*/
|
||||
limit=pBiDi->trailingWSStart;
|
||||
if(limit==0) {
|
||||
/* there is only WS on this line */
|
||||
getSingleRun(pBiDi, pBiDi->paraLevel);
|
||||
} else {
|
||||
UBiDiLevel *levels=pBiDi->levels;
|
||||
UTextOffset i, runCount;
|
||||
UBiDiLevel level=UBIDI_DEFAULT_LTR; /* initialize with no valid level */
|
||||
|
||||
/* count the runs, there is at least one non-WS run, and limit>0 */
|
||||
runCount=0;
|
||||
for(i=0; i<limit; ++i) {
|
||||
/* increment runCount at the start of each run */
|
||||
if(levels[i]!=level) {
|
||||
++runCount;
|
||||
level=levels[i];
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* We don't need to see if the last run can be merged with a trailing
|
||||
* WS run because setTrailingWSStart() would have done that.
|
||||
*/
|
||||
if(runCount==1 && limit==length) {
|
||||
/* There is only one non-WS run and no trailing WS-run. */
|
||||
getSingleRun(pBiDi, levels[0]);
|
||||
} else /* runCount>1 || limit<length */ {
|
||||
/* allocate and set the runs */
|
||||
Run *runs;
|
||||
UTextOffset runIndex, start;
|
||||
UBiDiLevel minLevel=UBIDI_MAX_EXPLICIT_LEVEL+1, maxLevel=0;
|
||||
|
||||
/* now, count a (non-mergable) WS run */
|
||||
if(limit<length) {
|
||||
++runCount;
|
||||
}
|
||||
|
||||
/* runCount>1 */
|
||||
if(getRunsMemory(pBiDi, runCount)) {
|
||||
runs=pBiDi->runsMemory;
|
||||
} else {
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/* set the runs */
|
||||
/* this could be optimized, e.g.: 464->444, 484->444, 575->555, 595->555 */
|
||||
/* however, that would take longer and make other functions more complicated */
|
||||
runIndex=0;
|
||||
|
||||
/* search for the run ends */
|
||||
start=0;
|
||||
level=levels[0];
|
||||
if(level<minLevel) {
|
||||
minLevel=level;
|
||||
}
|
||||
if(level>maxLevel) {
|
||||
maxLevel=level;
|
||||
}
|
||||
|
||||
/* initialize visualLimit values with the run lengths */
|
||||
for(i=1; i<limit; ++i) {
|
||||
if(levels[i]!=level) {
|
||||
/* i is another run limit */
|
||||
runs[runIndex].logicalStart=start;
|
||||
runs[runIndex].visualLimit=i-start;
|
||||
start=i;
|
||||
|
||||
level=levels[i];
|
||||
if(level<minLevel) {
|
||||
minLevel=level;
|
||||
}
|
||||
if(level>maxLevel) {
|
||||
maxLevel=level;
|
||||
}
|
||||
++runIndex;
|
||||
}
|
||||
}
|
||||
|
||||
/* finish the last run at i==limit */
|
||||
runs[runIndex].logicalStart=start;
|
||||
runs[runIndex].visualLimit=limit-start;
|
||||
++runIndex;
|
||||
|
||||
if(limit<length) {
|
||||
/* there is a separate WS run */
|
||||
runs[runIndex].logicalStart=limit;
|
||||
runs[runIndex].visualLimit=length-limit;
|
||||
if(pBiDi->paraLevel<minLevel) {
|
||||
minLevel=pBiDi->paraLevel;
|
||||
}
|
||||
}
|
||||
|
||||
/* set the object fields */
|
||||
pBiDi->runs=runs;
|
||||
pBiDi->runCount=runCount;
|
||||
|
||||
reorderLine(pBiDi, minLevel, maxLevel);
|
||||
|
||||
/* now add the direction flags and adjust the visualLimit's to be just that */
|
||||
ADD_ODD_BIT_FROM_LEVEL(runs[0].logicalStart, levels[runs[0].logicalStart]);
|
||||
limit=runs[0].visualLimit;
|
||||
for(i=1; i<runIndex; ++i) {
|
||||
ADD_ODD_BIT_FROM_LEVEL(runs[i].logicalStart, levels[runs[i].logicalStart]);
|
||||
limit=runs[i].visualLimit+=limit;
|
||||
}
|
||||
|
||||
/* same for the trailing WS run */
|
||||
if(runIndex<runCount) {
|
||||
ADD_ODD_BIT_FROM_LEVEL(runs[i].logicalStart, pBiDi->paraLevel);
|
||||
runs[runIndex].visualLimit+=limit;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/* in trivial cases there is only one trivial run; called by getRuns() */
|
||||
static void
|
||||
getSingleRun(UBiDi *pBiDi, UBiDiLevel level) {
|
||||
/* simple, single-run case */
|
||||
pBiDi->runs=pBiDi->simpleRuns;
|
||||
pBiDi->runCount=1;
|
||||
|
||||
/* fill and reorder the single run */
|
||||
pBiDi->runs[0].logicalStart=MAKE_INDEX_ODD_PAIR(0, level);
|
||||
pBiDi->runs[0].visualLimit=pBiDi->length;
|
||||
}
|
||||
|
||||
/* reorder the runs array (L2) ---------------------------------------------- */
|
||||
|
||||
/*
|
||||
* Reorder the same-level runs in the runs array.
|
||||
* Here, runCount>1 and maxLevel>=minLevel>=paraLevel.
|
||||
* All the visualStart fields=logical start before reordering.
|
||||
* The "odd" bits are not set yet.
|
||||
*
|
||||
* Reordering with this data structure lends itself to some handy shortcuts:
|
||||
*
|
||||
* Since each run is moved but not modified, and since at the initial maxLevel
|
||||
* each sequence of same-level runs consists of only one run each, we
|
||||
* don't need to do anything there and can predecrement maxLevel.
|
||||
* In many simple cases, the reordering is thus done entirely in the
|
||||
* index mapping.
|
||||
* Also, reordering occurs only down to the lowest odd level that occurs,
|
||||
* which is minLevel|1. However, if the lowest level itself is odd, then
|
||||
* in the last reordering the sequence of the runs at this level or higher
|
||||
* will be all runs, and we don't need the elaborate loop to search for them.
|
||||
* This is covered by ++minLevel instead of minLevel|=1 followed
|
||||
* by an extra reorder-all after the reorder-some loop.
|
||||
* About a trailing WS run:
|
||||
* Such a run would need special treatment because its level is not
|
||||
* reflected in levels[] if this is not a paragraph object.
|
||||
* Instead, all characters from trailingWSStart on are implicitly at
|
||||
* paraLevel.
|
||||
* However, for all maxLevel>paraLevel, this run will never be reordered
|
||||
* and does not need to be taken into account. maxLevel==paraLevel is only reordered
|
||||
* if minLevel==paraLevel is odd, which is done in the extra segment.
|
||||
* This means that for the main reordering loop we don't need to consider
|
||||
* this run and can --runCount. If it is later part of the all-runs
|
||||
* reordering, then runCount is adjusted accordingly.
|
||||
*/
|
||||
static void
|
||||
reorderLine(UBiDi *pBiDi, UBiDiLevel minLevel, UBiDiLevel maxLevel) {
|
||||
Run *runs;
|
||||
UBiDiLevel *levels;
|
||||
UTextOffset firstRun, endRun, limitRun, runCount,
|
||||
temp, trailingWSStart=pBiDi->trailingWSStart;
|
||||
|
||||
/* nothing to do? */
|
||||
if(maxLevel<=(minLevel|1)) {
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
* Reorder only down to the lowest odd level
|
||||
* and reorder at an odd minLevel in a separate, simpler loop.
|
||||
* See comments above for why minLevel is always incremented.
|
||||
*/
|
||||
++minLevel;
|
||||
|
||||
runs=pBiDi->runs;
|
||||
levels=pBiDi->levels;
|
||||
runCount=pBiDi->runCount;
|
||||
|
||||
/* do not include the WS run at paraLevel<=old minLevel except in the simple loop */
|
||||
if(pBiDi->trailingWSStart<pBiDi->length) {
|
||||
--runCount;
|
||||
}
|
||||
|
||||
while(--maxLevel>=minLevel) {
|
||||
firstRun=0;
|
||||
|
||||
/* loop for all sequences of runs */
|
||||
for(;;) {
|
||||
/* look for a sequence of runs that are all at >=maxLevel */
|
||||
/* look for the first run of such a sequence */
|
||||
while(firstRun<runCount && levels[runs[firstRun].logicalStart]<maxLevel) {
|
||||
++firstRun;
|
||||
}
|
||||
if(firstRun>=runCount) {
|
||||
break; /* no more such runs */
|
||||
}
|
||||
|
||||
/* look for the limit run of such a sequence (the run behind it) */
|
||||
for(limitRun=firstRun; ++limitRun<runCount && levels[runs[limitRun].logicalStart]>=maxLevel;) {}
|
||||
|
||||
/* Swap the entire sequence of runs from firstRun to limitRun-1. */
|
||||
endRun=limitRun-1;
|
||||
while(firstRun<endRun) {
|
||||
temp=runs[firstRun].logicalStart;
|
||||
runs[firstRun].logicalStart=runs[endRun].logicalStart;
|
||||
runs[endRun].logicalStart=temp;
|
||||
|
||||
temp=runs[firstRun].visualLimit;
|
||||
runs[firstRun].visualLimit=runs[endRun].visualLimit;
|
||||
runs[endRun].visualLimit=temp;
|
||||
|
||||
++firstRun;
|
||||
--endRun;
|
||||
}
|
||||
|
||||
if(limitRun==runCount) {
|
||||
break; /* no more such runs */
|
||||
} else {
|
||||
firstRun=limitRun+1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* now do maxLevel==old minLevel (==odd!), see above */
|
||||
if(!(minLevel&1)) {
|
||||
firstRun=0;
|
||||
|
||||
/* include the trailing WS run in this complete reordering */
|
||||
if(pBiDi->trailingWSStart==pBiDi->length) {
|
||||
--runCount;
|
||||
}
|
||||
|
||||
/* Swap the entire sequence of all runs. (endRun==runCount) */
|
||||
while(firstRun<runCount) {
|
||||
temp=runs[firstRun].logicalStart;
|
||||
runs[firstRun].logicalStart=runs[runCount].logicalStart;
|
||||
runs[runCount].logicalStart=temp;
|
||||
|
||||
temp=runs[firstRun].visualLimit;
|
||||
runs[firstRun].visualLimit=runs[runCount].visualLimit;
|
||||
runs[runCount].visualLimit=temp;
|
||||
|
||||
++firstRun;
|
||||
--runCount;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* reorder a line based on a levels array (L2) ------------------------------ */
|
||||
|
||||
CAPI void U_EXPORT2
|
||||
ubidi_reorderLogical(const UBiDiLevel *levels, UTextOffset length, UTextOffset *indexMap) {
|
||||
UTextOffset start, limit, sumOfSosEos;
|
||||
UBiDiLevel minLevel, maxLevel;
|
||||
|
||||
if(indexMap==NULL || !prepareReorder(levels, length, indexMap, &minLevel, &maxLevel)) {
|
||||
return;
|
||||
}
|
||||
|
||||
/* nothing to do? */
|
||||
if(minLevel==maxLevel && (minLevel&1)==0) {
|
||||
return;
|
||||
}
|
||||
|
||||
/* reorder only down to the lowest odd level */
|
||||
minLevel|=1;
|
||||
|
||||
/* loop maxLevel..minLevel */
|
||||
do {
|
||||
start=0;
|
||||
|
||||
/* loop for all sequences of levels to reorder at the current maxLevel */
|
||||
for(;;) {
|
||||
/* look for a sequence of levels that are all at >=maxLevel */
|
||||
/* look for the first index of such a sequence */
|
||||
while(start<length && levels[start]<maxLevel) {
|
||||
++start;
|
||||
}
|
||||
if(start>=length) {
|
||||
break; /* no more such sequences */
|
||||
}
|
||||
|
||||
/* look for the limit of such a sequence (the index behind it) */
|
||||
for(limit=start; ++limit<length && levels[limit]>=maxLevel;) {}
|
||||
|
||||
/*
|
||||
* sos=start of sequence, eos=end of sequence
|
||||
*
|
||||
* The closed (inclusive) interval from sos to eos includes all the logical
|
||||
* and visual indexes within this sequence. They are logically and
|
||||
* visually contiguous and in the same range.
|
||||
*
|
||||
* For each run, the new visual index=sos+eos-old visual index;
|
||||
* we pre-add sos+eos into sumOfSosEos ->
|
||||
* new visual index=sumOfSosEos-old visual index;
|
||||
*/
|
||||
sumOfSosEos=start+limit-1;
|
||||
|
||||
/* reorder each index in the sequence */
|
||||
do {
|
||||
indexMap[start]=sumOfSosEos-indexMap[start];
|
||||
} while(++start<limit);
|
||||
|
||||
/* start==limit */
|
||||
if(limit==length) {
|
||||
break; /* no more such sequences */
|
||||
} else {
|
||||
start=limit+1;
|
||||
}
|
||||
}
|
||||
} while(--maxLevel>=minLevel);
|
||||
}
|
||||
|
||||
CAPI void U_EXPORT2
|
||||
ubidi_reorderVisual(const UBiDiLevel *levels, UTextOffset length, UTextOffset *indexMap) {
|
||||
UTextOffset start, end, limit, temp;
|
||||
UBiDiLevel minLevel, maxLevel;
|
||||
|
||||
if(indexMap==NULL || !prepareReorder(levels, length, indexMap, &minLevel, &maxLevel)) {
|
||||
return;
|
||||
}
|
||||
|
||||
/* nothing to do? */
|
||||
if(minLevel==maxLevel && (minLevel&1)==0) {
|
||||
return;
|
||||
}
|
||||
|
||||
/* reorder only down to the lowest odd level */
|
||||
minLevel|=1;
|
||||
|
||||
/* loop maxLevel..minLevel */
|
||||
do {
|
||||
start=0;
|
||||
|
||||
/* loop for all sequences of levels to reorder at the current maxLevel */
|
||||
for(;;) {
|
||||
/* look for a sequence of levels that are all at >=maxLevel */
|
||||
/* look for the first index of such a sequence */
|
||||
while(start<length && levels[start]<maxLevel) {
|
||||
++start;
|
||||
}
|
||||
if(start>=length) {
|
||||
break; /* no more such runs */
|
||||
}
|
||||
|
||||
/* look for the limit of such a sequence (the index behind it) */
|
||||
for(limit=start; ++limit<length && levels[limit]>=maxLevel;) {}
|
||||
|
||||
/*
|
||||
* Swap the entire interval of indexes from start to limit-1.
|
||||
* We don't need to swap the levels for the purpose of this
|
||||
* algorithm: the sequence of levels that we look at does not
|
||||
* move anyway.
|
||||
*/
|
||||
end=limit-1;
|
||||
while(start<end) {
|
||||
temp=indexMap[start];
|
||||
indexMap[start]=indexMap[end];
|
||||
indexMap[end]=temp;
|
||||
|
||||
++start;
|
||||
--end;
|
||||
}
|
||||
|
||||
if(limit==length) {
|
||||
break; /* no more such sequences */
|
||||
} else {
|
||||
start=limit+1;
|
||||
}
|
||||
}
|
||||
} while(--maxLevel>=minLevel);
|
||||
}
|
||||
|
||||
static bool_t
|
||||
prepareReorder(const UBiDiLevel *levels, UTextOffset length,
|
||||
UTextOffset *indexMap,
|
||||
UBiDiLevel *pMinLevel, UBiDiLevel *pMaxLevel) {
|
||||
UTextOffset start;
|
||||
UBiDiLevel level, minLevel, maxLevel;
|
||||
|
||||
if(levels==NULL || length<=0) {
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/* determine minLevel and maxLevel */
|
||||
minLevel=UBIDI_MAX_EXPLICIT_LEVEL+1;
|
||||
maxLevel=0;
|
||||
for(start=length; start>0;) {
|
||||
level=levels[--start];
|
||||
if(level>UBIDI_MAX_EXPLICIT_LEVEL+1) {
|
||||
return FALSE;
|
||||
}
|
||||
if(level<minLevel) {
|
||||
minLevel=level;
|
||||
}
|
||||
if(level>maxLevel) {
|
||||
maxLevel=level;
|
||||
}
|
||||
}
|
||||
*pMinLevel=minLevel;
|
||||
*pMaxLevel=maxLevel;
|
||||
|
||||
/* initialize the index map */
|
||||
for(start=length; start>0;) {
|
||||
--start;
|
||||
indexMap[start]=start;
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/* API functions for logical<->visual mapping ------------------------------- */
|
||||
|
||||
CAPI UTextOffset U_EXPORT2
|
||||
ubidi_getVisualIndex(UBiDi *pBiDi, UTextOffset logicalIndex, UErrorCode *pErrorCode) {
|
||||
if(pErrorCode==NULL || FAILURE(*pErrorCode)) {
|
||||
return 0;
|
||||
} else if(pBiDi==NULL || logicalIndex<0 || pBiDi->length<=logicalIndex) {
|
||||
*pErrorCode=ILLEGAL_ARGUMENT_ERROR;
|
||||
return 0;
|
||||
} else {
|
||||
/* we can do the trivial cases without the runs array */
|
||||
switch(pBiDi->direction) {
|
||||
case UBIDI_LTR:
|
||||
return logicalIndex;
|
||||
case UBIDI_RTL:
|
||||
return pBiDi->length-logicalIndex-1;
|
||||
default:
|
||||
if(pBiDi->runCount<0 && !getRuns(pBiDi)) {
|
||||
*pErrorCode=MEMORY_ALLOCATION_ERROR;
|
||||
return 0;
|
||||
} else {
|
||||
Run *runs=pBiDi->runs;
|
||||
UTextOffset i, visualStart=0, offset, length;
|
||||
|
||||
/* linear search for the run, search on the visual runs */
|
||||
for(i=0;; ++i) {
|
||||
length=runs[i].visualLimit-visualStart;
|
||||
offset=logicalIndex-GET_INDEX(runs[i].logicalStart);
|
||||
if(offset>=0 && offset<length) {
|
||||
if(IS_EVEN_RUN(runs[i].logicalStart)) {
|
||||
/* LTR */
|
||||
return visualStart+offset;
|
||||
} else {
|
||||
/* RTL */
|
||||
return visualStart+length-offset-1;
|
||||
}
|
||||
}
|
||||
visualStart+=length;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
CAPI UTextOffset U_EXPORT2
|
||||
ubidi_getLogicalIndex(UBiDi *pBiDi, UTextOffset visualIndex, UErrorCode *pErrorCode) {
|
||||
if(pErrorCode==NULL || FAILURE(*pErrorCode)) {
|
||||
return 0;
|
||||
} else if(pBiDi==NULL || visualIndex<0 || pBiDi->length<=visualIndex) {
|
||||
*pErrorCode=ILLEGAL_ARGUMENT_ERROR;
|
||||
return 0;
|
||||
} else {
|
||||
/* we can do the trivial cases without the runs array */
|
||||
switch(pBiDi->direction) {
|
||||
case UBIDI_LTR:
|
||||
return visualIndex;
|
||||
case UBIDI_RTL:
|
||||
return pBiDi->length-visualIndex-1;
|
||||
default:
|
||||
if(pBiDi->runCount<0 && !getRuns(pBiDi)) {
|
||||
*pErrorCode=MEMORY_ALLOCATION_ERROR;
|
||||
return 0;
|
||||
} else {
|
||||
Run *runs=pBiDi->runs;
|
||||
UTextOffset i, runCount=pBiDi->runCount, start;
|
||||
|
||||
if(runCount<=10) {
|
||||
/* linear search for the run */
|
||||
for(i=0; visualIndex>=runs[i].visualLimit; ++i) {}
|
||||
} else {
|
||||
/* binary search for the run */
|
||||
UTextOffset start=0, limit=runCount;
|
||||
|
||||
/* the middle if() will guaranteed find the run, we don't need a loop limit */
|
||||
for(;;) {
|
||||
i=(start+limit)/2;
|
||||
if(visualIndex>=runs[i].visualLimit) {
|
||||
start=i+1;
|
||||
} else if(i==0 || visualIndex>=runs[i-1].visualLimit) {
|
||||
break;
|
||||
} else {
|
||||
limit=i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
start=runs[i].logicalStart;
|
||||
if(IS_EVEN_RUN(start)) {
|
||||
/* LTR */
|
||||
/* the offset in runs[i] is visualIndex-runs[i-1].visualLimit */
|
||||
if(i>0) {
|
||||
visualIndex-=runs[i-1].visualLimit;
|
||||
}
|
||||
return GET_INDEX(start)+visualIndex;
|
||||
} else {
|
||||
/* RTL */
|
||||
return GET_INDEX(start)+runs[i].visualLimit-visualIndex-1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
CAPI void U_EXPORT2
|
||||
ubidi_getLogicalMap(UBiDi *pBiDi, UTextOffset *indexMap, UErrorCode *pErrorCode) {
|
||||
UBiDiLevel *levels;
|
||||
|
||||
/* ubidi_getLevels() checks all of its and our arguments */
|
||||
if((levels=(UBiDiLevel *)ubidi_getLevels(pBiDi, pErrorCode))==NULL) {
|
||||
/* no op */
|
||||
} else if(indexMap==NULL) {
|
||||
*pErrorCode=ILLEGAL_ARGUMENT_ERROR;
|
||||
} else {
|
||||
ubidi_reorderLogical(levels, pBiDi->length, indexMap);
|
||||
}
|
||||
}
|
||||
|
||||
CAPI void U_EXPORT2
|
||||
ubidi_getVisualMap(UBiDi *pBiDi, UTextOffset *indexMap, UErrorCode *pErrorCode) {
|
||||
/* ubidi_countRuns() checks all of its and our arguments */
|
||||
if(ubidi_countRuns(pBiDi, pErrorCode)<=0) {
|
||||
/* no op */
|
||||
} else if(indexMap==NULL) {
|
||||
*pErrorCode=ILLEGAL_ARGUMENT_ERROR;
|
||||
} else {
|
||||
/* fill a visual-to-logical index map using the runs[] */
|
||||
Run *runs=pBiDi->runs, *runsLimit=runs+pBiDi->runCount;
|
||||
UTextOffset logicalStart, visualStart, visualLimit;
|
||||
|
||||
visualStart=0;
|
||||
for(; runs<runsLimit; ++runs) {
|
||||
logicalStart=runs->logicalStart;
|
||||
visualLimit=runs->visualLimit;
|
||||
if(IS_EVEN_RUN(logicalStart)) {
|
||||
do { /* LTR */
|
||||
*indexMap++ = logicalStart++;
|
||||
} while(++visualStart<visualLimit);
|
||||
} else {
|
||||
REMOVE_ODD_BIT(logicalStart);
|
||||
logicalStart+=visualLimit-visualStart; /* logicalLimit */
|
||||
do { /* RTL */
|
||||
*indexMap++ = --logicalStart;
|
||||
} while(++visualStart<visualLimit);
|
||||
}
|
||||
/* visualStart==visualLimit; */
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
CAPI void U_EXPORT2
|
||||
ubidi_invertMap(const UTextOffset *srcMap, UTextOffset *destMap, UTextOffset length) {
|
||||
if(srcMap!=NULL && destMap!=NULL) {
|
||||
srcMap+=length;
|
||||
while(length>0) {
|
||||
destMap[*--srcMap]=--length;
|
||||
}
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -18,8 +18,9 @@
|
|||
* 04/02/97 aliu Creation.
|
||||
* 03/29/99 helena Updated for C APIs.
|
||||
* 4/15/99 Madhu Updated for C Implementation and Javadoc
|
||||
* 5/20/99 Madhu Added the function u_getVersion()
|
||||
* 8/19/1999 srl Upgraded scripts to Unicode 3.0
|
||||
* 5/20/99 Madhu Added the function u_getVersion()
|
||||
* 8/19/1999 srl Upgraded scripts to Unicode 3.0
|
||||
* 8/27/1999 schererm UCharDirection constants: U_...
|
||||
********************************************************************************
|
||||
*/
|
||||
|
||||
|
|
@ -139,27 +140,26 @@ typedef enum UCharCategory UCharCategory;
|
|||
*/
|
||||
|
||||
enum UCharDirection {
|
||||
LEFT_TO_RIGHT = 0,
|
||||
RIGHT_TO_LEFT = 1,
|
||||
EUROPEAN_NUMBER = 2,
|
||||
EUROPEAN_NUMBER_SEPARATOR = 3,
|
||||
EUROPEAN_NUMBER_TERMINATOR = 4,
|
||||
ARABIC_NUMBER = 5,
|
||||
COMMON_NUMBER_SEPARATOR = 6,
|
||||
BLOCK_SEPARATOR = 7,
|
||||
SEGMENT_SEPARATOR = 8,
|
||||
WHITE_SPACE_NEUTRAL = 9,
|
||||
OTHER_NEUTRAL = 10,
|
||||
LEFT_TO_RIGHT_EMBEDDING = 11,
|
||||
LEFT_TO_RIGHT_OVERRIDE = 12,
|
||||
RIGHT_TO_LEFT_ARABIC = 13,
|
||||
RIGHT_TO_LEFT_EMBEDDING = 14,
|
||||
RIGHT_TO_LEFT_OVERRIDE = 15,
|
||||
POP_DIRECTIONAL_FORMAT = 16,
|
||||
DIR_NON_SPACING_MARK = 17,
|
||||
BOUNDARY_NEUTRAL = 18
|
||||
|
||||
|
||||
U_LEFT_TO_RIGHT = 0,
|
||||
U_RIGHT_TO_LEFT = 1,
|
||||
U_EUROPEAN_NUMBER = 2,
|
||||
U_EUROPEAN_NUMBER_SEPARATOR = 3,
|
||||
U_EUROPEAN_NUMBER_TERMINATOR = 4,
|
||||
U_ARABIC_NUMBER = 5,
|
||||
U_COMMON_NUMBER_SEPARATOR = 6,
|
||||
U_BLOCK_SEPARATOR = 7,
|
||||
U_SEGMENT_SEPARATOR = 8,
|
||||
U_WHITE_SPACE_NEUTRAL = 9,
|
||||
U_OTHER_NEUTRAL = 10,
|
||||
U_LEFT_TO_RIGHT_EMBEDDING = 11,
|
||||
U_LEFT_TO_RIGHT_OVERRIDE = 12,
|
||||
U_RIGHT_TO_LEFT_ARABIC = 13,
|
||||
U_RIGHT_TO_LEFT_EMBEDDING = 14,
|
||||
U_RIGHT_TO_LEFT_OVERRIDE = 15,
|
||||
U_POP_DIRECTIONAL_FORMAT = 16,
|
||||
U_DIR_NON_SPACING_MARK = 17,
|
||||
U_BOUNDARY_NEUTRAL = 18,
|
||||
UCharDirectionCount
|
||||
};
|
||||
|
||||
typedef enum UCharDirection UCharDirection;
|
||||
|
|
|
|||
|
|
@ -258,6 +258,7 @@ int32_t ucnv_flushCache ()
|
|||
/*creates an enumeration to iterate through every element in the
|
||||
*table
|
||||
*/
|
||||
umtx_lock (NULL);
|
||||
while (mySharedData = (UConverterSharedData *) uhash_nextElement (SHARED_DATA_HASHTABLE, &pos))
|
||||
{
|
||||
/*deletes only if reference counter == 0 */
|
||||
|
|
@ -265,12 +266,13 @@ int32_t ucnv_flushCache ()
|
|||
{
|
||||
UErrorCode err = ZERO_ERROR;
|
||||
tableDeletedNum++;
|
||||
umtx_lock (NULL);
|
||||
|
||||
uhash_remove (SHARED_DATA_HASHTABLE, uhash_hashIString (mySharedData->name), &err);
|
||||
deleteSharedConverterData (mySharedData);
|
||||
umtx_unlock (NULL);
|
||||
|
||||
}
|
||||
}
|
||||
umtx_unlock (NULL);
|
||||
|
||||
return tableDeletedNum;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -404,10 +404,15 @@ void shareConverterData (UConverterSharedData * data)
|
|||
|
||||
if (SHARED_DATA_HASHTABLE == NULL)
|
||||
{
|
||||
umtx_lock (NULL);
|
||||
SHARED_DATA_HASHTABLE = uhash_open ((UHashFunction) uhash_hashSharedData, &err);
|
||||
umtx_unlock (NULL);
|
||||
UHashtable* myHT = uhash_openSize ((UHashFunction) uhash_hashSharedData,
|
||||
AVAILABLE_CONVERTERS,
|
||||
&err);
|
||||
if (FAILURE (err)) return;
|
||||
umtx_lock (NULL);
|
||||
if (SHARED_DATA_HASHTABLE == NULL) SHARED_DATA_HASHTABLE = myHT;
|
||||
else uhash_close(myHT);
|
||||
umtx_unlock (NULL);
|
||||
|
||||
}
|
||||
umtx_lock (NULL);
|
||||
uhash_put(SHARED_DATA_HASHTABLE,
|
||||
|
|
@ -493,32 +498,43 @@ bool_t isDataBasedConverter (const char *name)
|
|||
/*Lazy evaluates the hashtable */
|
||||
if (ALGORITHMIC_CONVERTERS_HASHTABLE == NULL)
|
||||
{
|
||||
umtx_lock (NULL);
|
||||
ALGORITHMIC_CONVERTERS_HASHTABLE = uhash_open ((UHashFunction)uhash_hashIString, &err);
|
||||
if (FAILURE (err))return FALSE;
|
||||
while (algorithmicConverterNames[i][0] != '\0')
|
||||
{
|
||||
/*Stores in the hashtable a pointer to the statically init'ed array containing
|
||||
*the names
|
||||
*/
|
||||
UHashtable* myHT;
|
||||
|
||||
{
|
||||
myHT = uhash_open (uhash_hashIString, &err);
|
||||
|
||||
uhash_put (ALGORITHMIC_CONVERTERS_HASHTABLE,
|
||||
(void *) algorithmicConverterNames[i],
|
||||
&err);
|
||||
i++; /*Some Compilers (Solaris WSpro and MSVC-Release Mode
|
||||
*don't differentiate between i++ and ++i
|
||||
*so we have to increment in a line by itself
|
||||
*/
|
||||
}
|
||||
if (FAILURE (err)) return FALSE;
|
||||
while (algorithmicConverterNames[i][0] != '\0')
|
||||
{
|
||||
/*Stores in the hashtable a pointer to the statically init'ed array containing
|
||||
*the names
|
||||
*/
|
||||
|
||||
uhash_put (myHT,
|
||||
(void *) algorithmicConverterNames[i],
|
||||
&err);
|
||||
i++; /*Some Compilers (Solaris WSpro and MSVC-Release Mode
|
||||
*don't differentiate between i++ and ++i
|
||||
*so we have to increment in a line by itself
|
||||
*/
|
||||
}
|
||||
}
|
||||
|
||||
umtx_lock (NULL);
|
||||
if (ALGORITHMIC_CONVERTERS_HASHTABLE == NULL) ALGORITHMIC_CONVERTERS_HASHTABLE = myHT;
|
||||
else uhash_close(myHT);
|
||||
umtx_unlock (NULL);
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
if (uhash_get (ALGORITHMIC_CONVERTERS_HASHTABLE,
|
||||
uhash_hashIString (name)) == NULL)
|
||||
{
|
||||
result = TRUE;
|
||||
}
|
||||
|
||||
|
||||
|
||||
return result;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -80,13 +80,16 @@ CAPI UHashtable*
|
|||
uhash_open(UHashFunction func,
|
||||
UErrorCode *status)
|
||||
{
|
||||
return uhash_openSize(func, 3, status);
|
||||
UHashtable* myUHT = uhash_openSize(func, 3, status);
|
||||
if (SUCCESS(*status)) myUHT->isGrowable = TRUE;
|
||||
|
||||
return myUHT;
|
||||
}
|
||||
|
||||
CAPI UHashtable*
|
||||
uhash_openSize(UHashFunction func,
|
||||
int32_t size,
|
||||
UErrorCode *status)
|
||||
int32_t size,
|
||||
UErrorCode *status)
|
||||
{
|
||||
UHashtable *result;
|
||||
|
||||
|
|
@ -104,6 +107,7 @@ uhash_openSize(UHashFunction func,
|
|||
result->valueDelete = NULL;
|
||||
result->toBeDeleted = NULL;
|
||||
result->toBeDeletedCount = 0;
|
||||
result->isGrowable = FALSE;
|
||||
|
||||
uhash_initialize(result, uhash_leastGreaterPrimeIndex(size), status);
|
||||
|
||||
|
|
@ -160,7 +164,11 @@ uhash_putKey(UHashtable *hash,
|
|||
if(FAILURE(*status)) return UHASH_INVALID;
|
||||
|
||||
if(hash->count > hash->highWaterMark) {
|
||||
uhash_rehash(hash, status);
|
||||
if (hash->isGrowable) uhash_rehash(hash, status);
|
||||
else {
|
||||
*status = INDEX_OUTOFBOUNDS_ERROR;
|
||||
return UHASH_INVALID;
|
||||
}
|
||||
}
|
||||
|
||||
hashCode = valueKey;
|
||||
|
|
@ -206,7 +214,11 @@ uhash_put(UHashtable *hash,
|
|||
if(FAILURE(*status)) return UHASH_INVALID;
|
||||
|
||||
if(hash->count > hash->highWaterMark) {
|
||||
uhash_rehash(hash, status);
|
||||
if (hash->isGrowable) uhash_rehash(hash, status);
|
||||
else {
|
||||
*status = INDEX_OUTOFBOUNDS_ERROR;
|
||||
return UHASH_INVALID;
|
||||
}
|
||||
}
|
||||
|
||||
hashCode = (hash->hashFunction)(value);
|
||||
|
|
|
|||
|
|
@ -65,6 +65,7 @@ struct UHashtable {
|
|||
|
||||
int32_t toBeDeletedCount;
|
||||
void** toBeDeleted;
|
||||
bool_t isGrowable;
|
||||
};
|
||||
typedef struct UHashtable UHashtable;
|
||||
|
||||
|
|
@ -75,20 +76,21 @@ typedef struct UHashtable UHashtable;
|
|||
* @return A pointer to a UHashtable, or 0 if an error occurred.
|
||||
* @see uhash_openSize
|
||||
*/
|
||||
CAPI UHashtable* U_EXPORT2
|
||||
CAPI UHashtable*
|
||||
uhash_open(UHashFunction func,
|
||||
UErrorCode *status);
|
||||
UErrorCode *status);
|
||||
|
||||
/**
|
||||
* Initialize a new UHashtable.
|
||||
* Initialize a new UHashtable with a given size. If after a sequence of uhash_put the table runs out of space
|
||||
* An error will be signalled by uhash_put.
|
||||
* @param hash A pointer to the UHashtable to be initialized.
|
||||
* @param func A pointer to the hashing function to be used by this hash table.
|
||||
* @param size The initial capacity of this hash table.
|
||||
* @param size The maximal capacity of this hash table.
|
||||
* @param status A pointer to an UErrorCode to receive any errors.
|
||||
* @return A pointer to a UHashtable, or 0 if an error occurred.
|
||||
* @see uhash_open
|
||||
*/
|
||||
CAPI UHashtable* U_EXPORT2
|
||||
CAPI UHashtable*
|
||||
uhash_openSize(UHashFunction func,
|
||||
int32_t size,
|
||||
UErrorCode *status);
|
||||
|
|
@ -97,11 +99,11 @@ uhash_openSize(UHashFunction func,
|
|||
* Close a UHashtable, releasing the memory used.
|
||||
* @param hash The UHashtable to close.
|
||||
*/
|
||||
CAPI void U_EXPORT2
|
||||
CAPI void
|
||||
uhash_close(UHashtable *hash);
|
||||
|
||||
|
||||
CAPI void U_EXPORT2
|
||||
CAPI void
|
||||
uhash_setValueDeleter(UHashtable *hash, ValueDeleter del);
|
||||
|
||||
/**
|
||||
|
|
@ -109,7 +111,7 @@ uhash_setValueDeleter(UHashtable *hash, ValueDeleter del);
|
|||
* @param hash The UHashtable to query.
|
||||
* @return The number of items stored in hash.
|
||||
*/
|
||||
CAPI int32_t U_EXPORT2
|
||||
CAPI int32_t
|
||||
uhash_size(const UHashtable *hash);
|
||||
|
||||
/**
|
||||
|
|
@ -120,7 +122,7 @@ uhash_size(const UHashtable *hash);
|
|||
* @return The hash code associated with value.
|
||||
* @see uhash_get
|
||||
*/
|
||||
CAPI int32_t U_EXPORT2
|
||||
CAPI int32_t
|
||||
uhash_put(UHashtable *hash,
|
||||
void *value,
|
||||
UErrorCode *status);
|
||||
|
|
@ -133,7 +135,7 @@ uhash_put(UHashtable *hash,
|
|||
* @return The hash code associated with value.
|
||||
* @see uhash_get
|
||||
*/
|
||||
CAPI int32_t U_EXPORT2
|
||||
CAPI int32_t
|
||||
uhash_putKey(UHashtable *hash,
|
||||
int32_t valueKey,
|
||||
void *value,
|
||||
|
|
@ -145,7 +147,7 @@ uhash_putKey(UHashtable *hash,
|
|||
* @param key The hash code of the desired value.
|
||||
* @return The requested item, or 0 if not found.
|
||||
*/
|
||||
CAPI void* U_EXPORT2
|
||||
CAPI void*
|
||||
uhash_get(const UHashtable *hash,
|
||||
int32_t key);
|
||||
|
||||
|
|
@ -156,7 +158,7 @@ uhash_get(const UHashtable *hash,
|
|||
* @param status A pointer to an UErrorCode to receive any errors.
|
||||
* @return The item removed, or 0 if not found.
|
||||
*/
|
||||
CAPI void* U_EXPORT2
|
||||
CAPI void*
|
||||
uhash_remove(UHashtable *hash,
|
||||
int32_t key,
|
||||
UErrorCode *status);
|
||||
|
|
@ -168,7 +170,7 @@ uhash_remove(UHashtable *hash,
|
|||
* the first value, and should subsequently not be changed by the caller.
|
||||
* @return The next item in the hash table, or 0 if no items remain.
|
||||
*/
|
||||
CAPI void* U_EXPORT2
|
||||
CAPI void*
|
||||
uhash_nextElement(const UHashtable *hash,
|
||||
int32_t *pos);
|
||||
|
||||
|
|
@ -188,7 +190,7 @@ uhash_nextElement(const UHashtable *hash,
|
|||
* @param parm The ustring (const UChar*) to hash.
|
||||
* @return A hash code for parm.
|
||||
*/
|
||||
CAPI int32_t U_EXPORT2
|
||||
CAPI int32_t
|
||||
uhash_hashUString(const void *parm);
|
||||
|
||||
/**
|
||||
|
|
@ -198,7 +200,7 @@ uhash_hashUString(const void *parm);
|
|||
* @param parm The string (const char*) to hash.
|
||||
* @return A hash code for parm.
|
||||
*/
|
||||
CAPI int32_t U_EXPORT2
|
||||
CAPI int32_t
|
||||
uhash_hashString(const void *parm);
|
||||
|
||||
/**
|
||||
|
|
@ -206,7 +208,7 @@ uhash_hashString(const void *parm);
|
|||
* @param parm The long (cast to void*) to hash.
|
||||
* @return A hash code for parm.
|
||||
*/
|
||||
CAPI int32_t U_EXPORT2
|
||||
CAPI int32_t
|
||||
uhash_hashLong(const void *parm);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ AC_INIT(common/utypes.h)
|
|||
AC_CONFIG_HEADER(common/icucfg.h)
|
||||
PACKAGE="icu"
|
||||
AC_SUBST(PACKAGE)
|
||||
VERSION="1.2.5"
|
||||
VERSION="1.3"
|
||||
AC_SUBST(VERSION)
|
||||
|
||||
dnl Checks for programs
|
||||
|
|
|
|||
183
source/extra/ustdio/ustdio.dsp
Normal file
183
source/extra/ustdio/ustdio.dsp
Normal file
|
|
@ -0,0 +1,183 @@
|
|||
# Microsoft Developer Studio Project File - Name="ustdio" - Package Owner=<4>
|
||||
# Microsoft Developer Studio Generated Build File, Format Version 6.00
|
||||
# ** DO NOT EDIT **
|
||||
|
||||
# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
|
||||
|
||||
CFG=ustdio - Win32 Debug
|
||||
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
|
||||
!MESSAGE use the Export Makefile command and run
|
||||
!MESSAGE
|
||||
!MESSAGE NMAKE /f "ustdio.mak".
|
||||
!MESSAGE
|
||||
!MESSAGE You can specify a configuration when running NMAKE
|
||||
!MESSAGE by defining the macro CFG on the command line. For example:
|
||||
!MESSAGE
|
||||
!MESSAGE NMAKE /f "ustdio.mak" CFG="ustdio - Win32 Debug"
|
||||
!MESSAGE
|
||||
!MESSAGE Possible choices for configuration are:
|
||||
!MESSAGE
|
||||
!MESSAGE "ustdio - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
|
||||
!MESSAGE "ustdio - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
|
||||
!MESSAGE
|
||||
|
||||
# Begin Project
|
||||
# PROP AllowPerConfigDependencies 0
|
||||
# PROP Scc_ProjName ""
|
||||
# PROP Scc_LocalPath ""
|
||||
CPP=cl.exe
|
||||
MTL=midl.exe
|
||||
RSC=rc.exe
|
||||
|
||||
!IF "$(CFG)" == "ustdio - Win32 Release"
|
||||
|
||||
# PROP BASE Use_MFC 0
|
||||
# PROP BASE Use_Debug_Libraries 0
|
||||
# PROP BASE Output_Dir "Release"
|
||||
# PROP BASE Intermediate_Dir "Release"
|
||||
# PROP BASE Target_Dir ""
|
||||
# PROP Use_MFC 0
|
||||
# PROP Use_Debug_Libraries 0
|
||||
# PROP Output_Dir "Release"
|
||||
# PROP Intermediate_Dir "Release"
|
||||
# PROP Ignore_Export_Lib 0
|
||||
# PROP Target_Dir ""
|
||||
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "USTDIO_EXPORTS" /YX /FD /c
|
||||
# ADD CPP /nologo /MD /W3 /GX /I "\icu\include\internal" /I "\icu\include" /I "..\..\common" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "USTDIO_EXPORTS" /YX /FD /c
|
||||
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
|
||||
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
|
||||
# ADD BASE RSC /l 0x409 /d "NDEBUG"
|
||||
# ADD RSC /l 0x409 /d "NDEBUG"
|
||||
BSC32=bscmake.exe
|
||||
# ADD BASE BSC32 /nologo
|
||||
# ADD BSC32 /nologo
|
||||
LINK32=link.exe
|
||||
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
|
||||
# ADD LINK32 \icu\lib\release\icuuc.lib \icu\lib\release\icui18n.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 /out:"\icu\bin\Release\ustdio.dll"
|
||||
|
||||
!ELSEIF "$(CFG)" == "ustdio - Win32 Debug"
|
||||
|
||||
# PROP BASE Use_MFC 0
|
||||
# PROP BASE Use_Debug_Libraries 1
|
||||
# PROP BASE Output_Dir "Debug"
|
||||
# PROP BASE Intermediate_Dir "Debug"
|
||||
# PROP BASE Target_Dir ""
|
||||
# PROP Use_MFC 0
|
||||
# PROP Use_Debug_Libraries 1
|
||||
# PROP Output_Dir "Debug"
|
||||
# PROP Intermediate_Dir "Debug"
|
||||
# PROP Ignore_Export_Lib 0
|
||||
# PROP Target_Dir ""
|
||||
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "USTDIO_EXPORTS" /YX /FD /GZ /c
|
||||
# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "..\..\common" /I "\icu\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "USTDIO_EXPORTS" /YX /FD /GZ /c
|
||||
# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
|
||||
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
|
||||
# ADD BASE RSC /l 0x409 /d "_DEBUG"
|
||||
# ADD RSC /l 0x409 /d "_DEBUG"
|
||||
BSC32=bscmake.exe
|
||||
# ADD BASE BSC32 /nologo
|
||||
# ADD BSC32 /nologo
|
||||
LINK32=link.exe
|
||||
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
|
||||
# ADD LINK32 \icu\lib\debug\icuuc.lib \icu\lib\debug\icui18n.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /out:"\icu\bin\Debug\ustdio.dll" /pdbtype:sept
|
||||
|
||||
!ENDIF
|
||||
|
||||
# Begin Target
|
||||
|
||||
# Name "ustdio - Win32 Release"
|
||||
# Name "ustdio - Win32 Debug"
|
||||
# Begin Group "Source Files"
|
||||
|
||||
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\locbund.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\loccache.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\ufile.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\ufmt_cmn.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\uprintf.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\uprntf_p.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\uscanf.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\uscanf_p.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\uscanset.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\ustdio.c
|
||||
# End Source File
|
||||
# End Group
|
||||
# Begin Group "Header Files"
|
||||
|
||||
# PROP Default_Filter "h;hpp;hxx;hm;inl"
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\locbund.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\loccache.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\ufile.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\ufmt_cmn.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\uprintf.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\uprntf_p.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\uscanf.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\uscanf_p.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\uscanset.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\ustdio.h
|
||||
# End Source File
|
||||
# End Group
|
||||
# Begin Group "Resource Files"
|
||||
|
||||
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
|
||||
# End Group
|
||||
# End Target
|
||||
# End Project
|
||||
29
source/extra/ustdio/ustdio.dsw
Normal file
29
source/extra/ustdio/ustdio.dsw
Normal file
|
|
@ -0,0 +1,29 @@
|
|||
Microsoft Developer Studio Workspace File, Format Version 6.00
|
||||
# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
|
||||
|
||||
###############################################################################
|
||||
|
||||
Project: "ustdio"=.\ustdio.dsp - Package Owner=<4>
|
||||
|
||||
Package=<5>
|
||||
{{{
|
||||
}}}
|
||||
|
||||
Package=<4>
|
||||
{{{
|
||||
}}}
|
||||
|
||||
###############################################################################
|
||||
|
||||
Global:
|
||||
|
||||
Package=<5>
|
||||
{{{
|
||||
}}}
|
||||
|
||||
Package=<3>
|
||||
{{{
|
||||
}}}
|
||||
|
||||
###############################################################################
|
||||
|
||||
|
|
@ -1413,7 +1413,7 @@ RuleBasedCollator::build(const UnicodeString& pattern,
|
|||
|
||||
// check if french secondary needs to be turned on
|
||||
if ((groupChars.size() > 1) &&
|
||||
(groupChars[groupChars.size()-(T_INT32(1))] == '@'))
|
||||
(groupChars[groupChars.size()-(T_INT32(1))] == 0x0040))
|
||||
{
|
||||
data->isFrenchSec = TRUE;
|
||||
groupChars.remove(groupChars.size()-(T_INT32(1)));
|
||||
|
|
@ -2201,7 +2201,7 @@ RuleBasedCollator::chopLocale(UnicodeString& localeName)
|
|||
|
||||
for (i = size - 1; i > 0; i--)
|
||||
{
|
||||
if (localeName[i] == '_')
|
||||
if (localeName[i] == 0x005F)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -59,7 +59,8 @@ ccaltst.o ccapitst.o ccolltst.o cconvtst.o ccurrtst.o cdantst.o \
|
|||
cdattst.o cdetst.o cdtdptst.o cdtrgtst.o cestst.o cfintst.o cformtst.o \
|
||||
cfrtst.o cg7coll.o cintltst.o citertst.o cjaptst.o cloctst.o cmsgtst.o \
|
||||
cnmdptst.o cnormtst.o cnumtst.o cregrtst.o crestst.o cturtst.o \
|
||||
cucdtst.o cutiltst.o encoll.o nucnvtst.o susctest.o nccbtst.o
|
||||
cucdtst.o cutiltst.o encoll.o nucnvtst.o susctest.o nccbtst.o \
|
||||
cbiditst.o cbididat.o
|
||||
|
||||
DEPS = $(OBJECTS:.o=.d)
|
||||
|
||||
|
|
@ -104,6 +105,3 @@ $(TARGET) : $(OBJECTS)
|
|||
ifneq ($(MAKECMDGOALS),distclean)
|
||||
-include $(DEPS)
|
||||
endif
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -28,6 +28,8 @@ void addFormatTest(TestNode** root);
|
|||
void addConvert(TestNode** root);
|
||||
void addCollTest(TestNode** root);
|
||||
void addSUSCTest(TestNode** root);
|
||||
void addComplexTest(TestNode** root);
|
||||
|
||||
void addAllTests(TestNode** root)
|
||||
{
|
||||
addUtility(root);
|
||||
|
|
@ -35,5 +37,6 @@ void addAllTests(TestNode** root)
|
|||
addFormatTest(root);
|
||||
addConvert(root);
|
||||
addCollTest(root);
|
||||
addSUSCTest(root);
|
||||
addSUSCTest(root);
|
||||
addComplexTest(root);
|
||||
}
|
||||
|
|
|
|||
386
source/test/cintltst/cbididat.c
Normal file
386
source/test/cintltst/cbididat.c
Normal file
|
|
@ -0,0 +1,386 @@
|
|||
/*
|
||||
*******************************************************************************
|
||||
* *
|
||||
* COPYRIGHT: *
|
||||
* (C) Copyright International Business Machines Corporation, 1999 *
|
||||
* Licensed Material - Program-Property of IBM - All Rights Reserved. *
|
||||
* US Government Users Restricted Rights - Use, duplication, or disclosure *
|
||||
* restricted by GSA ADP Schedule Contract with IBM Corp. *
|
||||
* *
|
||||
*******************************************************************************
|
||||
* file name: cbididat.c
|
||||
* encoding: US-ASCII
|
||||
* tab size: 8 (not used)
|
||||
* indentation:4
|
||||
*
|
||||
* created on: 1999sep22
|
||||
* created by: Markus W. Scherer
|
||||
*/
|
||||
|
||||
#include "utypes.h"
|
||||
#include "uchar.h"
|
||||
#include "ubidi.h"
|
||||
#include "cbiditst.h"
|
||||
|
||||
extern const char *
|
||||
dirPropNames[dirPropCount]={
|
||||
"L", "R", "EN", "ES", "ET", "AN", "CS", "B", "S", "WS", "ON",
|
||||
"LRE", "LRO", "AL", "RLE", "RLO", "PDF", "NSM", "BN"
|
||||
};
|
||||
|
||||
extern const UChar
|
||||
charFromDirProp[dirPropCount]={
|
||||
/* L R EN ES ET AN CS B S WS ON */
|
||||
0x61, 0x5d0, 0x30, 0x2f, 0x25, 0x660, 0x2c, 0xa, 0x9, 0x20, 0x26,
|
||||
/* LRE LRO AL RLE RLO PDF NSM BN */
|
||||
0x202a, 0x202d, 0x627, 0x202b, 0x202e, 0x202c, 0x308, 0x200c
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testText1[]={
|
||||
L, L, WS, L, WS, EN, L, B
|
||||
};
|
||||
|
||||
static const UBiDiLevel
|
||||
testLevels1[]={
|
||||
0, 0, 0, 0, 0, 0, 0, 0
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testVisualMap1[]={
|
||||
0, 1, 2, 3, 4, 5, 6, 7
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testText2[]={
|
||||
R, AL, WS, R, AL, WS, R
|
||||
};
|
||||
|
||||
static const UBiDiLevel
|
||||
testLevels2[]={
|
||||
1, 1, 1, 1, 1, 1, 1
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testVisualMap2[]={
|
||||
6, 5, 4, 3, 2, 1, 0
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testText3[]={
|
||||
L, L, WS, EN, CS, WS, EN, CS, EN, WS, L, L
|
||||
};
|
||||
|
||||
static const UBiDiLevel
|
||||
testLevels3[]={
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testVisualMap3[]={
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testText4[]={
|
||||
L, AL, AL, AL, L, AL, AL, L, WS, EN, CS, WS, EN, CS, EN, WS, L, L
|
||||
};
|
||||
|
||||
static const UBiDiLevel
|
||||
testLevels4[]={
|
||||
0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testVisualMap4[]={
|
||||
0, 3, 2, 1, 4, 6, 5, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testText5[]={
|
||||
AL, R, AL, WS, EN, CS, WS, EN, CS, EN, WS, R, R, WS, L, L
|
||||
};
|
||||
|
||||
static const UBiDiLevel
|
||||
testLevels5[]={
|
||||
1, 1, 1, 1, 2, 1, 1, 2, 2, 2, 1, 1, 1, 1, 2, 2
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testVisualMap5[]={
|
||||
15, 14, 13, 12, 11, 10, 9, 6, 7, 8, 5, 4, 3, 2, 0, 1
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testText6[]={
|
||||
R, EN, NSM, ET
|
||||
};
|
||||
|
||||
static const UBiDiLevel
|
||||
testLevels6[]={
|
||||
1, 2, 2, 2
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testVisualMap6[]={
|
||||
3, 0, 1, 2
|
||||
};
|
||||
|
||||
#if 0
|
||||
static const uint8_t
|
||||
testText7[]={
|
||||
/* empty */
|
||||
};
|
||||
|
||||
static const UBiDiLevel
|
||||
testLevels7[]={
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testVisualMap7[]={
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
static const uint8_t
|
||||
testText8[]={
|
||||
RLE, WS, R, R, R, WS, PDF, WS, B
|
||||
};
|
||||
|
||||
static const UBiDiLevel
|
||||
testLevels8[]={
|
||||
1, 1, 1, 1, 1, 1, 1, 1, 1
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testVisualMap8[]={
|
||||
8, 7, 6, 5, 4, 3, 2, 1, 0
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testText9[]={
|
||||
LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE,
|
||||
LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE,
|
||||
AN, RLO, NSM, LRE, PDF, RLE, ES, EN, ON
|
||||
};
|
||||
|
||||
static const UBiDiLevel
|
||||
testLevels9[]={
|
||||
62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 61, 61, 61, 61, 61, 61, 61, 61
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testVisualMap9[]={
|
||||
8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 7, 6, 5, 4, 3, 2, 1, 0
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testText10[]={
|
||||
LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE,
|
||||
LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE, LRE,
|
||||
LRE, BN, CS, RLO, S, PDF, EN, LRO, AN, ES
|
||||
};
|
||||
|
||||
static const UBiDiLevel
|
||||
testLevels10[]={
|
||||
60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 0, 0, 62, 62, 62, 62, 60
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testVisualMap10[]={
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testText11[]={
|
||||
S, WS, NSM, RLE, WS, L, L, L, WS, LRO, WS, R, R, R, WS, RLO, WS, L, L,
|
||||
L, WS, LRE, WS, R, R, R, WS, PDF, WS, L, L, L, WS, PDF, WS,
|
||||
AL, AL, AL, WS, PDF, WS, L, L, L, WS, PDF, WS, L, L, L, WS, PDF,
|
||||
ON, PDF, BN, BN, ON, PDF
|
||||
};
|
||||
|
||||
static const UBiDiLevel
|
||||
testLevels11[]={
|
||||
0, 0, 0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 5, 5, 5, 4, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testVisualMap11[]={
|
||||
0, 1, 2, 44, 43, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 31, 30, 29, 28, 27, 26, 20, 21, 24, 23, 22, 25, 19, 18, 17, 16, 15, 14, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 3, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testText12[]={
|
||||
NSM, WS, L, L, L, L, L, L, L, WS, L, L, L, L, WS,
|
||||
R, R, R, R, R, WS, L, L, L, L, L, L, L, WS, WS, AL,
|
||||
AL, AL, AL, WS, EN, EN, ES, EN, EN, CS, S, EN, EN, CS, WS,
|
||||
EN, EN, WS, AL, AL, AL, AL, AL, B, L, L, L, L, L, L,
|
||||
L, L, WS, AN, AN, CS, AN, AN, WS
|
||||
};
|
||||
|
||||
static const UBiDiLevel
|
||||
testLevels12[]={
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 1, 2, 2, 1, 0, 2, 2, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 0
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testVisualMap12[]={
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 19, 18, 17, 16, 15, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 40, 39, 38, 37, 36, 34, 35, 33, 31, 32, 30, 41, 52, 53, 51, 50, 48, 49, 47, 46, 45, 44, 43, 42, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69
|
||||
};
|
||||
|
||||
static const UBiDiLevel
|
||||
testLevels13[]={
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 1, 2, 2, 1, 0, 2, 2, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 0
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testVisualMap13[]={
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 19, 18, 17, 16, 15, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 40, 39, 38, 37, 36, 34, 35, 33, 31, 32, 30, 41, 52, 53, 51, 50, 48, 49, 47, 46, 45, 44, 43, 42, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69
|
||||
};
|
||||
|
||||
static const UBiDiLevel
|
||||
testLevels14[]={
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 3, 4, 4, 3, 2, 4, 4, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 4, 4, 4, 4, 4, 2
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testVisualMap14[]={
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 19, 18, 17, 16, 15, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 40, 39, 38, 37, 36, 34, 35, 33, 31, 32, 30, 41, 52, 53, 51, 50, 48, 49, 47, 46, 45, 44, 43, 42, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69
|
||||
};
|
||||
|
||||
static const UBiDiLevel
|
||||
testLevels15[]={
|
||||
5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 5, 6, 6, 5, 6, 6, 5, 5, 6, 6, 5, 5, 6, 6, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 5, 6, 6, 6, 6, 6, 5
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testVisualMap15[]={
|
||||
69, 68, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 55, 54, 53, 52, 51, 50, 49, 42, 43, 44, 45, 46, 47, 48, 41, 40, 39, 38, 37, 36, 35, 33, 34, 32, 30, 31, 29, 28, 26, 27, 25, 24, 22, 23, 21, 20, 19, 18, 17, 16, 15, 7, 8, 9, 10, 11, 12, 13, 14, 6, 1, 2, 3, 4, 5, 0
|
||||
};
|
||||
|
||||
static const UBiDiLevel
|
||||
testLevels16[]={
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 1, 2, 2, 1, 0, 2, 2, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 0
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testVisualMap16[]={
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 19, 18, 17, 16, 15, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 40, 39, 38, 37, 36, 34, 35, 33, 31, 32, 30, 41, 52, 53, 51, 50, 48, 49, 47, 46, 45, 44, 43, 42, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testText13[]={
|
||||
ON, L, RLO, CS, R, WS, AN, AN, PDF, LRE, R, L, LRO, WS, BN, ON, S, LRE, LRO, B
|
||||
};
|
||||
|
||||
static const UBiDiLevel
|
||||
testLevels17[]={
|
||||
0, 0, 1, 1, 1, 1, 1, 1, 3, 3, 3, 2, 4, 4, 4, 4, 0, 0, 0, 0
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testVisualMap17[]={
|
||||
0, 1, 15, 14, 13, 12, 11, 10, 4, 3, 2, 5, 6, 7, 8, 9, 16, 17, 18, 19
|
||||
};
|
||||
|
||||
static const UBiDiLevel
|
||||
testLevels18[]={
|
||||
0, 0, 1, 1, 1, 0
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testVisualMap18[]={
|
||||
0, 1, 4, 3, 2, 5
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testText14[]={
|
||||
RLO, RLO, AL, AL, WS, EN, ES, ON, WS, S, S, PDF, LRO, WS, AL, ET, RLE, ON, EN, B
|
||||
};
|
||||
|
||||
static const UBiDiLevel
|
||||
testLevels19[]={
|
||||
1
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testVisualMap19[]={
|
||||
0
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
testText15[]={
|
||||
R, L, CS, L
|
||||
};
|
||||
|
||||
static const UBiDiLevel
|
||||
testLevels20[]={
|
||||
2
|
||||
};
|
||||
|
||||
extern BiDiTestData
|
||||
tests[]={
|
||||
testText1, ARRAY_LENGTH(testText1), UBIDI_DEFAULT_LTR, -1, -1,
|
||||
UBIDI_LTR, 0,
|
||||
testLevels1, testVisualMap1,
|
||||
testText2, ARRAY_LENGTH(testText2), UBIDI_DEFAULT_LTR, -1, -1,
|
||||
UBIDI_RTL, 1,
|
||||
testLevels2, testVisualMap2,
|
||||
testText3, ARRAY_LENGTH(testText3), UBIDI_DEFAULT_LTR, -1, -1,
|
||||
UBIDI_LTR, 0,
|
||||
testLevels3, testVisualMap3,
|
||||
testText4, ARRAY_LENGTH(testText4), UBIDI_DEFAULT_LTR, -1, -1,
|
||||
UBIDI_MIXED, 0,
|
||||
testLevels4, testVisualMap4,
|
||||
testText5, ARRAY_LENGTH(testText5), UBIDI_DEFAULT_LTR, -1, -1,
|
||||
UBIDI_MIXED, 1,
|
||||
testLevels5, testVisualMap5,
|
||||
testText6, ARRAY_LENGTH(testText6), UBIDI_DEFAULT_LTR, -1, -1,
|
||||
UBIDI_MIXED, 1,
|
||||
testLevels6, testVisualMap6,
|
||||
NULL, 0, UBIDI_DEFAULT_LTR, -1, -1,
|
||||
UBIDI_LTR, 0,
|
||||
NULL, NULL,
|
||||
testText8, ARRAY_LENGTH(testText8), UBIDI_DEFAULT_LTR, -1, -1,
|
||||
UBIDI_RTL, 1,
|
||||
testLevels8, testVisualMap8,
|
||||
testText9, ARRAY_LENGTH(testText9), UBIDI_DEFAULT_LTR, -1, -1,
|
||||
UBIDI_MIXED, 0,
|
||||
testLevels9, testVisualMap9,
|
||||
testText10, ARRAY_LENGTH(testText10), UBIDI_DEFAULT_LTR, -1, -1,
|
||||
UBIDI_MIXED, 0,
|
||||
testLevels10, testVisualMap10,
|
||||
testText11, ARRAY_LENGTH(testText11), UBIDI_DEFAULT_LTR, -1, -1,
|
||||
UBIDI_MIXED, 0,
|
||||
testLevels11, testVisualMap11,
|
||||
testText12, ARRAY_LENGTH(testText12), UBIDI_DEFAULT_LTR, -1, -1,
|
||||
UBIDI_MIXED, 0,
|
||||
testLevels12, testVisualMap12,
|
||||
testText12, ARRAY_LENGTH(testText12), UBIDI_DEFAULT_RTL, -1, -1,
|
||||
UBIDI_MIXED, 0,
|
||||
testLevels13, testVisualMap13,
|
||||
testText12, ARRAY_LENGTH(testText12), 2, -1, -1,
|
||||
UBIDI_MIXED, 2,
|
||||
testLevels14, testVisualMap14,
|
||||
testText12, ARRAY_LENGTH(testText12), 5, -1, -1,
|
||||
UBIDI_MIXED, 5,
|
||||
testLevels15, testVisualMap15,
|
||||
testText12, ARRAY_LENGTH(testText12), UBIDI_DEFAULT_LTR, -1, -1,
|
||||
UBIDI_MIXED, 0,
|
||||
testLevels16, testVisualMap16,
|
||||
testText13, ARRAY_LENGTH(testText13), UBIDI_DEFAULT_LTR, -1, -1,
|
||||
UBIDI_MIXED, 0,
|
||||
testLevels17, testVisualMap17,
|
||||
testText13, ARRAY_LENGTH(testText13), UBIDI_DEFAULT_LTR, 0, 6,
|
||||
UBIDI_MIXED, 0,
|
||||
testLevels18, testVisualMap18,
|
||||
testText14, ARRAY_LENGTH(testText14), UBIDI_DEFAULT_LTR, 13, 14,
|
||||
UBIDI_RTL, 1,
|
||||
testLevels19, testVisualMap19,
|
||||
testText15, ARRAY_LENGTH(testText15), UBIDI_DEFAULT_LTR, 2, 3,
|
||||
UBIDI_LTR, 2,
|
||||
testLevels20, testVisualMap19
|
||||
};
|
||||
|
||||
extern int
|
||||
bidiTestCount=ARRAY_LENGTH(tests);
|
||||
373
source/test/cintltst/cbiditst.c
Normal file
373
source/test/cintltst/cbiditst.c
Normal file
|
|
@ -0,0 +1,373 @@
|
|||
/*
|
||||
*******************************************************************************
|
||||
* *
|
||||
* COPYRIGHT: *
|
||||
* (C) Copyright International Business Machines Corporation, 1999 *
|
||||
* Licensed Material - Program-Property of IBM - All Rights Reserved. *
|
||||
* US Government Users Restricted Rights - Use, duplication, or disclosure *
|
||||
* restricted by GSA ADP Schedule Contract with IBM Corp. *
|
||||
* *
|
||||
*******************************************************************************
|
||||
* file name: cbiditst.cpp
|
||||
* encoding: US-ASCII
|
||||
* tab size: 8 (not used)
|
||||
* indentation:4
|
||||
*
|
||||
* created on: 1999sep27
|
||||
* created by: Markus W. Scherer
|
||||
*/
|
||||
|
||||
#include "cintltst.h"
|
||||
#include "utypes.h"
|
||||
#include "uchar.h"
|
||||
#include "ubidi.h"
|
||||
#include "cbiditst.h"
|
||||
|
||||
/*
|
||||
* If this is defined, then a failed test terminates.
|
||||
*/
|
||||
#define DO_FAIL
|
||||
|
||||
/* prototypes ---------------------------------------------------------------*/
|
||||
|
||||
extern void
|
||||
doBiDiTest();
|
||||
|
||||
static void
|
||||
doTests(UBiDi *pBiDi, UBiDi *pLine);
|
||||
|
||||
static void
|
||||
doTest(UBiDi *pBiDi, int testNumber, BiDiTestData *test, UTextOffset lineStart);
|
||||
|
||||
static void
|
||||
testReordering(UBiDi *pBiDi, int testNumber);
|
||||
|
||||
static char *levelString;
|
||||
|
||||
static UChar *
|
||||
getStringFromDirProps(const uint8_t *dirProps, UTextOffset length);
|
||||
|
||||
/* regression tests ---------------------------------------------------------*/
|
||||
|
||||
extern void
|
||||
addComplexTest(TestNode** root) {
|
||||
addTest(root, doBiDiTest, "complex/bidi/regression");
|
||||
}
|
||||
|
||||
extern void
|
||||
doBiDiTest() {
|
||||
UBiDi *pBiDi, *pLine=NULL;
|
||||
UErrorCode errorCode=ZERO_ERROR;
|
||||
|
||||
log_verbose("*** bidi regression test ***\n");
|
||||
|
||||
pBiDi=ubidi_openSized(MAX_STRING_LENGTH, 0, &errorCode);
|
||||
if(pBiDi!=NULL) {
|
||||
pLine=ubidi_open();
|
||||
if(pLine!=NULL) {
|
||||
doTests(pBiDi, pLine);
|
||||
} else {
|
||||
log_err("ubidi_open() returned NULL, out of memory\n");
|
||||
}
|
||||
} else {
|
||||
log_err("ubidi_openSized() returned NULL, errorCode %s\n", myErrorName(errorCode));
|
||||
}
|
||||
|
||||
if(pLine!=NULL) {
|
||||
ubidi_close(pLine);
|
||||
}
|
||||
if(pBiDi!=NULL) {
|
||||
ubidi_close(pBiDi);
|
||||
}
|
||||
|
||||
log_verbose("*** bidi regression test finished ***\n");
|
||||
}
|
||||
|
||||
static void
|
||||
doTests(UBiDi *pBiDi, UBiDi *pLine) {
|
||||
int i;
|
||||
UChar *s;
|
||||
UErrorCode errorCode;
|
||||
UTextOffset lineStart;
|
||||
UBiDiLevel paraLevel;
|
||||
|
||||
for(i=0; i<bidiTestCount; ++i) {
|
||||
errorCode=ZERO_ERROR;
|
||||
s=getStringFromDirProps(tests[i].text, tests[i].length);
|
||||
paraLevel=tests[i].paraLevel;
|
||||
ubidi_setPara(pBiDi, s, -1, paraLevel, NULL, &errorCode);
|
||||
if(SUCCESS(errorCode)) {
|
||||
log_verbose("ubidi_setPara(tests[%d], paraLevel %d) ok, direction %d paraLevel=%d\n",
|
||||
i, paraLevel, ubidi_getDirection(pBiDi), ubidi_getParaLevel(pBiDi));
|
||||
lineStart=tests[i].lineStart;
|
||||
if(lineStart==-1) {
|
||||
doTest(pBiDi, i, tests+i, 0);
|
||||
} else {
|
||||
ubidi_setLine(pBiDi, lineStart, tests[i].lineLimit, pLine, &errorCode);
|
||||
if(SUCCESS(errorCode)) {
|
||||
log_verbose("ubidi_setLine(%d, %d) ok, direction %d paraLevel=%d\n",
|
||||
lineStart, tests[i].lineLimit, ubidi_getDirection(pLine), ubidi_getParaLevel(pLine));
|
||||
doTest(pLine, i, tests+i, lineStart);
|
||||
} else {
|
||||
log_err("ubidi_setLine(tests[%d], %d, %d) failed with errorCode %s\n",
|
||||
i, lineStart, tests[i].lineLimit, myErrorName(errorCode));
|
||||
}
|
||||
}
|
||||
} else {
|
||||
log_err("ubidi_setPara(tests[%d], paraLevel %d) failed with errorCode %s\n",
|
||||
i, paraLevel, myErrorName(errorCode));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
doTest(UBiDi *pBiDi, int testNumber, BiDiTestData *test, UTextOffset lineStart) {
|
||||
const uint8_t *dirProps=test->text+lineStart;
|
||||
const UBiDiLevel *levels=test->levels;
|
||||
const uint8_t *visualMap=test->visualMap;
|
||||
UTextOffset i, len=ubidi_getLength(pBiDi), logicalIndex, runCount;
|
||||
UErrorCode errorCode=ZERO_ERROR;
|
||||
UBiDiLevel level, level2;
|
||||
|
||||
testReordering(pBiDi, testNumber);
|
||||
|
||||
for(i=0; i<len; ++i) {
|
||||
log_verbose("%3d %3d %.*s%-3s @%d\n",
|
||||
i, ubidi_getLevelAt(pBiDi, i), ubidi_getLevelAt(pBiDi, i), levelString,
|
||||
dirPropNames[dirProps[i]],
|
||||
ubidi_getVisualIndex(pBiDi, i, &errorCode));
|
||||
}
|
||||
|
||||
log_verbose("\n-----levels:");
|
||||
for(i=0; i<len; ++i) {
|
||||
if(i>0) {
|
||||
log_verbose(",");
|
||||
}
|
||||
log_verbose(" %d", ubidi_getLevelAt(pBiDi, i));
|
||||
}
|
||||
|
||||
log_verbose("\n--reordered:");
|
||||
for(i=0; i<len; ++i) {
|
||||
if(i>0) {
|
||||
log_verbose(",");
|
||||
}
|
||||
log_verbose(" %d", ubidi_getVisualIndex(pBiDi, i, &errorCode));
|
||||
}
|
||||
log_verbose("\n");
|
||||
|
||||
if(test->direction!=ubidi_getDirection(pBiDi)) {
|
||||
log_err("ubidi_getDirection(tests[%d]): wrong direction %d\n", testNumber, ubidi_getDirection(pBiDi));
|
||||
}
|
||||
|
||||
if(test->resultLevel!=ubidi_getParaLevel(pBiDi)) {
|
||||
log_err("ubidi_getParaLevel(tests[%d]): wrong paragraph level %d\n", testNumber, ubidi_getParaLevel(pBiDi));
|
||||
}
|
||||
|
||||
for(i=0; i<len; ++i) {
|
||||
if(levels[i]!=ubidi_getLevelAt(pBiDi, i)) {
|
||||
log_err("ubidi_getLevelAt(tests[%d], %d): wrong level %d\n", testNumber, i, ubidi_getLevelAt(pBiDi, i));
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
for(i=0; i<len; ++i) {
|
||||
logicalIndex=ubidi_getVisualIndex(pBiDi, i, &errorCode);
|
||||
if(FAILURE(errorCode)) {
|
||||
log_err("ubidi_getVisualIndex(tests[%d], %d): error %s\n", testNumber, i, myErrorName(errorCode));
|
||||
return;
|
||||
}
|
||||
if(visualMap[i]!=logicalIndex) {
|
||||
log_err("ubidi_getVisualIndex(tests[%d], %d): wrong index %d\n", testNumber, i, logicalIndex);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
runCount=ubidi_countRuns(pBiDi, &errorCode);
|
||||
if(FAILURE(errorCode)) {
|
||||
log_err("ubidi_countRuns(tests[%d]): error %s\n", testNumber, myErrorName(errorCode));
|
||||
return;
|
||||
}
|
||||
|
||||
for(logicalIndex=0; logicalIndex<len;) {
|
||||
level=ubidi_getLevelAt(pBiDi, logicalIndex);
|
||||
ubidi_getLogicalRun(pBiDi, logicalIndex, &logicalIndex, &level2);
|
||||
if(level!=level2) {
|
||||
log_err("ubidi_getLogicalRun(tests[%d], run ending at index %d): wrong level %d\n", testNumber, logicalIndex, level2);
|
||||
}
|
||||
if(--runCount<0) {
|
||||
log_err("\nubidi_getLogicalRun(tests[%d]): wrong number of runs compared to %d=ubidi_getRunCount()\n", testNumber, ubidi_countRuns(pBiDi, &errorCode));
|
||||
return;
|
||||
}
|
||||
}
|
||||
if(runCount!=0) {
|
||||
log_err("\nubidi_getLogicalRun(tests[%d]): wrong number of runs compared to %d=ubidi_getRunCount()\n", testNumber, ubidi_countRuns(pBiDi, &errorCode));
|
||||
return;
|
||||
}
|
||||
|
||||
log_verbose("\n\n");
|
||||
}
|
||||
|
||||
static void
|
||||
testReordering(UBiDi *pBiDi, int testNumber) {
|
||||
UTextOffset
|
||||
logicalMap1[200], logicalMap2[200], logicalMap3[200],
|
||||
visualMap1[200], visualMap2[200], visualMap3[200], visualMap4[200];
|
||||
UErrorCode errorCode=ZERO_ERROR;
|
||||
UBiDiLevel levels[200];
|
||||
UTextOffset i, length=ubidi_getLength(pBiDi);
|
||||
UTextOffset runCount, visualIndex, logicalStart, runLength;
|
||||
int result=0;
|
||||
bool_t odd;
|
||||
|
||||
if(length<=0) {
|
||||
return;
|
||||
}
|
||||
|
||||
/* get the logical and visual maps from the object */
|
||||
ubidi_getLogicalMap(pBiDi, logicalMap1, &errorCode);
|
||||
if(FAILURE(errorCode)) {
|
||||
log_err("ubidi_getLogicalMap(tests[%d]): error %s\n", testNumber, myErrorName(errorCode));
|
||||
return;
|
||||
}
|
||||
|
||||
ubidi_getVisualMap(pBiDi, visualMap1, &errorCode);
|
||||
|
||||
if(FAILURE(errorCode)) {
|
||||
log_err("ubidi_getVisualMap(tests[%d]): error %s\n", testNumber, myErrorName(errorCode));
|
||||
return;
|
||||
}
|
||||
|
||||
/* invert them both */
|
||||
ubidi_invertMap(logicalMap1, visualMap2, length);
|
||||
ubidi_invertMap(visualMap1, logicalMap2, length);
|
||||
|
||||
/* get them from the levels array, too */
|
||||
memcpy(levels, ubidi_getLevels(pBiDi, &errorCode), length);
|
||||
if(FAILURE(errorCode)) {
|
||||
log_err("ubidi_getLevels(tests[%d]): error %s\n", testNumber, myErrorName(errorCode));
|
||||
return;
|
||||
}
|
||||
|
||||
ubidi_reorderLogical(levels, length, logicalMap3);
|
||||
ubidi_reorderVisual(levels, length, visualMap3);
|
||||
|
||||
/* get the visual map from the runs, too */
|
||||
runCount=ubidi_countRuns(pBiDi, &errorCode);
|
||||
if(FAILURE(errorCode)) {
|
||||
log_err("ubidi_countRuns(tests[%d]): error %s\n", testNumber, myErrorName(errorCode));
|
||||
return;
|
||||
}
|
||||
|
||||
log_verbose("\n----%2d runs:", runCount);
|
||||
for(i=0; i<runCount; ++i) {
|
||||
odd=ubidi_getVisualRun(pBiDi, i, &logicalStart, &runLength);
|
||||
log_verbose(" (%c @%d[%d])", odd ? 'R' : 'L', logicalStart, runLength);
|
||||
}
|
||||
log_verbose("\n");
|
||||
|
||||
visualIndex=0;
|
||||
for(i=0; i<runCount; ++i) {
|
||||
if(UBIDI_LTR==ubidi_getVisualRun(pBiDi, i, &logicalStart, &runLength)) {
|
||||
do { /* LTR */
|
||||
visualMap4[visualIndex++]=logicalStart++;
|
||||
} while(--runLength>0);
|
||||
} else {
|
||||
logicalStart+=runLength; /* logicalLimit */
|
||||
do { /* RTL */
|
||||
visualMap4[visualIndex++]=--logicalStart;
|
||||
} while(--runLength>0);
|
||||
}
|
||||
}
|
||||
|
||||
/* print all the maps */
|
||||
log_verbose("logical maps:\n");
|
||||
for(i=0; i<length; ++i) {
|
||||
log_verbose("%4d", logicalMap1[i]);
|
||||
}
|
||||
log_verbose("\n");
|
||||
for(i=0; i<length; ++i) {
|
||||
log_verbose("%4d", logicalMap2[i]);
|
||||
}
|
||||
log_verbose("\n");
|
||||
for(i=0; i<length; ++i) {
|
||||
log_verbose("%4d", logicalMap3[i]);
|
||||
}
|
||||
|
||||
log_verbose("\nvisual maps:\n");
|
||||
for(i=0; i<length; ++i) {
|
||||
log_verbose("%4d", visualMap1[i]);
|
||||
}
|
||||
log_verbose("\n");
|
||||
for(i=0; i<length; ++i) {
|
||||
log_verbose("%4d", visualMap2[i]);
|
||||
}
|
||||
log_verbose("\n");
|
||||
for(i=0; i<length; ++i) {
|
||||
log_verbose("%4d", visualMap3[i]);
|
||||
}
|
||||
log_verbose("\n");
|
||||
for(i=0; i<length; ++i) {
|
||||
log_verbose("%4d", visualMap4[i]);
|
||||
}
|
||||
log_verbose("\n");
|
||||
|
||||
/* check that the indexes are the same between these and ubidi_getLogical/VisualIndex() */
|
||||
for(i=0; i<length; ++i) {
|
||||
if(logicalMap1[i]!=logicalMap2[i]) {
|
||||
log_verbose("bidi reordering error in tests[%d]: logicalMap1[i]!=logicalMap2[i] at i=%d\n", testNumber, i);
|
||||
break;
|
||||
}
|
||||
if(logicalMap1[i]!=logicalMap3[i]) {
|
||||
log_verbose("bidi reordering error in tests[%d]: logicalMap1[i]!=logicalMap3[i] at i=%d\n", testNumber, i);
|
||||
break;
|
||||
}
|
||||
|
||||
if(visualMap1[i]!=visualMap2[i]) {
|
||||
log_verbose("bidi reordering error in tests[%d]: visualMap1[i]!=visualMap2[i] at i=%d\n", testNumber, i);
|
||||
break;
|
||||
}
|
||||
if(visualMap1[i]!=visualMap3[i]) {
|
||||
log_verbose("bidi reordering error in tests[%d]: visualMap1[i]!=visualMap3[i] at i=%d\n", testNumber, i);
|
||||
break;
|
||||
}
|
||||
if(visualMap1[i]!=visualMap4[i]) {
|
||||
log_verbose("bidi reordering error in tests[%d]: visualMap1[i]!=visualMap4[i] at i=%d\n", testNumber, i);
|
||||
break;
|
||||
}
|
||||
|
||||
if(logicalMap1[i]!=ubidi_getVisualIndex(pBiDi, i, &errorCode)) {
|
||||
log_verbose("bidi reordering error in tests[%d]: logicalMap1[i]!=ubidi_getVisualIndex(i) at i=%d\n", testNumber, i);
|
||||
break;
|
||||
}
|
||||
if(FAILURE(errorCode)) {
|
||||
log_verbose("ubidi_getVisualIndex(tests[%d], %d): error %s\n", testNumber, i, myErrorName(errorCode));
|
||||
break;
|
||||
}
|
||||
if(visualMap1[i]!=ubidi_getLogicalIndex(pBiDi, i, &errorCode)) {
|
||||
log_verbose("bidi reordering error in tests[%d]: visualMap1[i]!=ubidi_getLogicalIndex(i) at i=%d\n", testNumber, i);
|
||||
break;
|
||||
}
|
||||
if(FAILURE(errorCode)) {
|
||||
log_verbose("ubidi_getLogicalIndex(tests[%d], %d): error %s\n", testNumber, i, myErrorName(errorCode));
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* helpers ------------------------------------------------------------------*/
|
||||
|
||||
static char *levelString="...............................................................";
|
||||
|
||||
/* return a string with characters according to the desired directional properties */
|
||||
static UChar *
|
||||
getStringFromDirProps(const uint8_t *dirProps, UTextOffset length) {
|
||||
static UChar s[MAX_STRING_LENGTH];
|
||||
UTextOffset i;
|
||||
|
||||
/* this part would have to be modified for UTF-x */
|
||||
for(i=0; i<length; ++i) {
|
||||
s[i]=charFromDirProp[dirProps[i]];
|
||||
}
|
||||
s[i]=0;
|
||||
return s;
|
||||
}
|
||||
90
source/test/cintltst/cbiditst.h
Normal file
90
source/test/cintltst/cbiditst.h
Normal file
|
|
@ -0,0 +1,90 @@
|
|||
/*
|
||||
*******************************************************************************
|
||||
* *
|
||||
* COPYRIGHT: *
|
||||
* (C) Copyright International Business Machines Corporation, 1999 *
|
||||
* Licensed Material - Program-Property of IBM - All Rights Reserved. *
|
||||
* US Government Users Restricted Rights - Use, duplication, or disclosure *
|
||||
* restricted by GSA ADP Schedule Contract with IBM Corp. *
|
||||
* *
|
||||
*******************************************************************************
|
||||
* file name: cbiditst.h
|
||||
* encoding: US-ASCII
|
||||
* tab size: 8 (not used)
|
||||
* indentation:4
|
||||
*
|
||||
* created on: 1999sep22
|
||||
* created by: Markus W. Scherer
|
||||
*/
|
||||
|
||||
#ifndef CBIDITST_H
|
||||
#define CBIDITST_H
|
||||
|
||||
#include "utypes.h"
|
||||
#include "uchar.h"
|
||||
#include "ubidi.h"
|
||||
|
||||
#ifdef XP_CPLUSPLUS
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define MAX_STRING_LENGTH 200
|
||||
|
||||
/* length of an array */
|
||||
#define ARRAY_LENGTH(array) (sizeof(array)/sizeof(array[0]))
|
||||
|
||||
/* 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
|
||||
};
|
||||
|
||||
extern const char *
|
||||
dirPropNames[dirPropCount];
|
||||
|
||||
extern const UChar
|
||||
charFromDirProp[dirPropCount];
|
||||
|
||||
typedef struct {
|
||||
const uint8_t *text;
|
||||
UTextOffset length;
|
||||
UBiDiLevel paraLevel;
|
||||
UTextOffset lineStart, lineLimit;
|
||||
UBiDiDirection direction;
|
||||
UBiDiLevel resultLevel;
|
||||
const UBiDiLevel *levels;
|
||||
const uint8_t *visualMap;
|
||||
} BiDiTestData;
|
||||
|
||||
extern BiDiTestData
|
||||
tests[];
|
||||
|
||||
extern int
|
||||
bidiTestCount;
|
||||
|
||||
#ifdef XP_CPLUSPLUS
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -42,7 +42,7 @@ RSC=rc.exe
|
|||
# PROP Ignore_Export_Lib 0
|
||||
# PROP Target_Dir ""
|
||||
# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
|
||||
# ADD CPP /nologo /MDd /W3 /GX /I "\icu\include" /I "\icu\source\tools\ctestfw" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
|
||||
# ADD CPP /nologo /MDd /W3 /GX /I "..\..\..\include" /I "..\..\tools\ctestfw" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
|
||||
# ADD BASE RSC /l 0x409 /d "NDEBUG"
|
||||
# ADD RSC /l 0x409 /d "NDEBUG"
|
||||
BSC32=bscmake.exe
|
||||
|
|
@ -50,7 +50,7 @@ BSC32=bscmake.exe
|
|||
# ADD BSC32 /nologo
|
||||
LINK32=link.exe
|
||||
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
|
||||
# ADD LINK32 \icu\lib\release\icuuc.lib \icu\lib\release\icui18n.lib \icu\lib\release\ctestfw.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
|
||||
# ADD LINK32 ..\..\..\lib\release\icuuc.lib ..\..\..\lib\release\icui18n.lib ..\..\..\lib\release\ctestfw.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
|
||||
|
||||
!ELSEIF "$(CFG)" == "cintltst - Win32 Debug"
|
||||
|
||||
|
|
@ -66,7 +66,7 @@ LINK32=link.exe
|
|||
# PROP Ignore_Export_Lib 0
|
||||
# PROP Target_Dir ""
|
||||
# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
|
||||
# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "\icu\include" /I "\icu\source\tools\ctestfw" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
|
||||
# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "..\..\..\include" /I "..\..\tools\ctestfw" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
|
||||
# ADD BASE RSC /l 0x409 /d "_DEBUG"
|
||||
# ADD RSC /l 0x409 /d "_DEBUG"
|
||||
BSC32=bscmake.exe
|
||||
|
|
@ -74,7 +74,7 @@ BSC32=bscmake.exe
|
|||
# ADD BSC32 /nologo
|
||||
LINK32=link.exe
|
||||
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
|
||||
# ADD LINK32 \icu\lib\debug\icuuc.lib \icu\lib\debug\icui18n.lib \icu\lib\debug\ctestfw.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
|
||||
# ADD LINK32 ..\..\..\lib\debug\icuuc.lib ..\..\..\lib\debug\icui18n.lib ..\..\..\lib\debug\ctestfw.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
|
||||
|
||||
!ENDIF
|
||||
|
||||
|
|
@ -103,6 +103,14 @@ SOURCE=.\cbiapts.c
|
|||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\cbididat.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\cbiditst.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\cbkittst.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
|
@ -251,6 +259,10 @@ SOURCE=.\cbiapts.h
|
|||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\cbiditst.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\ccaltst.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
|
|
|||
|
|
@ -319,7 +319,7 @@ void TestUnicodeData()
|
|||
char newPath[256];
|
||||
|
||||
strcpy(newPath,icu_getDefaultDataDirectory());
|
||||
strcat(newPath, "UnicodeData-3.0.0.beta.txt");
|
||||
strcat(newPath, "UnicodeData-3.0.0.txt");
|
||||
|
||||
input = fopen(newPath, "r");
|
||||
|
||||
|
|
|
|||
|
|
@ -15,6 +15,7 @@
|
|||
*
|
||||
* Date Name Description
|
||||
* 05/17/99 stephen Creation (ported from java)
|
||||
* 09/24/99 stephen Added new test for data split on decompression.
|
||||
*******************************************************************************
|
||||
*/
|
||||
|
||||
|
|
@ -29,7 +30,16 @@
|
|||
#include "utypes.h"
|
||||
#include "cintltst.h"
|
||||
|
||||
#ifdef MIN
|
||||
# undef MIN
|
||||
#endif
|
||||
|
||||
#define MIN(a,b) (a < b ? a : b)
|
||||
|
||||
#ifdef MAX
|
||||
# undef MAX
|
||||
#endif
|
||||
|
||||
#define MAX(a,b) (a > b ? a : b)
|
||||
|
||||
|
||||
|
|
@ -94,12 +104,14 @@
|
|||
#define UQUOTEU 0xF0
|
||||
#define UDEFINEX 0xF1
|
||||
|
||||
static int32_t digitvalue(char c)
|
||||
static int32_t
|
||||
digitvalue(char c)
|
||||
{
|
||||
return c - 0x30 - (c >= 0x41 ? (c >= 0x61 ? 39 : 7) : 0);
|
||||
}
|
||||
|
||||
static UChar* unescape(const char *s)
|
||||
static UChar*
|
||||
unescape(const char *s)
|
||||
{
|
||||
UChar *retval;
|
||||
UChar *alias;
|
||||
|
|
@ -135,8 +147,9 @@ static UChar* unescape(const char *s)
|
|||
return retval;
|
||||
}
|
||||
|
||||
static void printChars(const UChar *chars,
|
||||
int32_t len)
|
||||
static void
|
||||
printChars(const UChar *chars,
|
||||
int32_t len)
|
||||
{
|
||||
int32_t i;
|
||||
|
||||
|
|
@ -147,8 +160,9 @@ static void printChars(const UChar *chars,
|
|||
}
|
||||
|
||||
|
||||
static void printChars2(const UChar *chars,
|
||||
int32_t len)
|
||||
static void
|
||||
printChars2(const UChar *chars,
|
||||
int32_t len)
|
||||
{
|
||||
int32_t i;
|
||||
|
||||
|
|
@ -162,8 +176,9 @@ static void printChars2(const UChar *chars,
|
|||
}
|
||||
|
||||
|
||||
static void printBytes(const uint8_t *byteBuffer,
|
||||
int32_t len)
|
||||
static void
|
||||
printBytes(const uint8_t *byteBuffer,
|
||||
int32_t len)
|
||||
{
|
||||
int32_t curByteIndex = 0;
|
||||
int32_t byteBufferLimit = len;
|
||||
|
|
@ -287,10 +302,11 @@ static void printBytes(const uint8_t *byteBuffer,
|
|||
puts("");
|
||||
}
|
||||
|
||||
static bool_t printDiffs(const UChar *s1,
|
||||
int32_t s1len,
|
||||
const UChar *s2,
|
||||
int32_t s2len)
|
||||
static bool_t
|
||||
printDiffs(const UChar *s1,
|
||||
int32_t s1len,
|
||||
const UChar *s2,
|
||||
int32_t s2len)
|
||||
{
|
||||
bool_t result = FALSE;
|
||||
int32_t len;
|
||||
|
|
@ -327,9 +343,10 @@ static bool_t printDiffs(const UChar *s1,
|
|||
}
|
||||
|
||||
/* generate a run of characters in a "window" */
|
||||
static void randomRun(UChar *target,
|
||||
int32_t pos,
|
||||
int32_t len)
|
||||
static void
|
||||
randomRun(UChar *target,
|
||||
int32_t pos,
|
||||
int32_t len)
|
||||
{
|
||||
int32_t offset = (int32_t)(0xFFFF * (double)(rand()/(double)RAND_MAX));
|
||||
int32_t i;
|
||||
|
|
@ -344,7 +361,8 @@ static void randomRun(UChar *target,
|
|||
}
|
||||
|
||||
/* generate a string of characters, with simulated runs of characters */
|
||||
static UChar* randomChars(int32_t len)
|
||||
static UChar*
|
||||
randomChars(int32_t len)
|
||||
{
|
||||
UChar *result = 0;
|
||||
int32_t runLen = 0;
|
||||
|
|
@ -367,8 +385,9 @@ static UChar* randomChars(int32_t len)
|
|||
return result;
|
||||
}
|
||||
|
||||
static void myTest(const UChar *chars,
|
||||
int32_t len)
|
||||
static void
|
||||
myTest(const UChar *chars,
|
||||
int32_t len)
|
||||
{
|
||||
UnicodeCompressor myCompressor;
|
||||
|
||||
|
|
@ -460,8 +479,9 @@ static void myTest(const UChar *chars,
|
|||
#define COMPRESSIONBUFFERSIZE 4
|
||||
#define DECOMPRESSIONBUFFERSIZE 2
|
||||
|
||||
static void myMultipassTest(const UChar *chars,
|
||||
int32_t len)
|
||||
static void
|
||||
myMultipassTest(const UChar *chars,
|
||||
int32_t len)
|
||||
{
|
||||
UnicodeCompressor myCompressor;
|
||||
|
||||
|
|
@ -641,18 +661,133 @@ static char *fTestCases [] = {
|
|||
|
||||
static unsigned long gTotalChars;
|
||||
|
||||
void signal_handler(int signal)
|
||||
/* unused unless this is run as a main in an infinite loop */
|
||||
void
|
||||
signal_handler(int signal)
|
||||
{
|
||||
printf("total chars compressed = %llu\n", gTotalChars);
|
||||
exit(0);
|
||||
}
|
||||
|
||||
int TestSCSU()
|
||||
|
||||
/* Decompress the two segments */
|
||||
static UChar*
|
||||
segment_test(uint8_t *segment1,
|
||||
int32_t seg1Len,
|
||||
uint8_t *segment2,
|
||||
int32_t seg2Len)
|
||||
{
|
||||
UErrorCode status = ZERO_ERROR;
|
||||
UnicodeCompressor myDecompressor;
|
||||
|
||||
const uint8_t *seg1 = segment1;
|
||||
const uint8_t *seg2 = segment2;
|
||||
|
||||
int32_t charBufferCap = 2*(seg1Len + seg2Len);
|
||||
UChar *charBuffer = (UChar*) malloc(sizeof(UChar) * charBufferCap);
|
||||
|
||||
UChar *target = charBuffer;
|
||||
int32_t outCount = 0, count1 = 0, count2 = 0;
|
||||
|
||||
|
||||
scsu_init(&myDecompressor);
|
||||
|
||||
scsu_decompress(&myDecompressor, &target, charBuffer + charBufferCap,
|
||||
&seg1, segment1 + seg1Len, &status);
|
||||
|
||||
count1 = seg1 - segment1;
|
||||
|
||||
/* println("Segment 1 (" + segment1.length + " bytes) " +
|
||||
"decompressed into " + count1 + " chars");
|
||||
println("Bytes consumed: " + bytesRead[0]);
|
||||
|
||||
print("Got chars: ");
|
||||
println(System.out, charBuffer, 0, count1);*/
|
||||
|
||||
/*s.append(charBuffer, 0, count1);*/
|
||||
|
||||
scsu_decompress(&myDecompressor, &target,
|
||||
charBuffer + charBufferCap,
|
||||
&seg2, segment2 + seg2Len, &status);
|
||||
|
||||
count2 = seg2 - segment2;
|
||||
|
||||
outCount = (target - charBuffer);
|
||||
|
||||
/* println("Segment 2 (" + segment2.length + " bytes) " +
|
||||
"decompressed into " + count2 + " chars");
|
||||
println("Bytes consumed: " + bytesRead[0]);
|
||||
|
||||
print("Got chars: ");
|
||||
println(System.out, charBuffer, count1, count2);*/
|
||||
|
||||
/*s.append(charBuffer, count1, count2);*/
|
||||
|
||||
/*print("Result: ");
|
||||
println(System.out, charBuffer, 0, count1 + count2);
|
||||
println("====================");*/
|
||||
|
||||
charBuffer [ outCount ] = 0x0000;
|
||||
return charBuffer;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
TestSCSU()
|
||||
{
|
||||
UChar *chars = 0;
|
||||
int32_t len = 0;
|
||||
int32_t i;
|
||||
|
||||
/* multi-segment test data */
|
||||
|
||||
/* compressed segment breaking on a define window sequence */
|
||||
/* B o o t h SD1 */
|
||||
uint8_t segment1a [] = { 0x42, 0x6f, 0x6f, 0x74, 0x68, 0x19 };
|
||||
/* IDX , S . */
|
||||
uint8_t segment1b [] = { 0x01, 0x2c, 0x20, 0x53, 0x2e };
|
||||
/* expected result */
|
||||
UChar result1 [] = { 0x0042, 0x006f, 0x006f, 0x0074, 0x0068,
|
||||
0x002c, 0x0020, 0x0053, 0x002e, 0x0000 };
|
||||
|
||||
/* compressed segment breaking on a quote unicode sequence */
|
||||
/* B o o t SQU */
|
||||
uint8_t segment2a [] = { 0x42, 0x6f, 0x6f, 0x74, 0x0e, 0x00 };
|
||||
|
||||
/* h , S . */
|
||||
uint8_t segment2b [] = { 0x68, 0x2c, 0x20, 0x53, 0x2e };
|
||||
/* expected result */
|
||||
UChar result2 [] = { 0x0042, 0x006f, 0x006f, 0x0074, 0x0068,
|
||||
0x002c, 0x0020, 0x0053, 0x002e, 0x0000 };
|
||||
|
||||
/* compressed segment breaking on a quote unicode sequence */
|
||||
/* SCU UQU */
|
||||
uint8_t segment3a [] = { 0x0f, 0xf0, 0x00 };
|
||||
|
||||
/* B */
|
||||
uint8_t segment3b [] = { 0x42 };
|
||||
/* expected result */
|
||||
UChar result3 [] = { 0x0042, 0x0000 };
|
||||
|
||||
|
||||
chars = segment_test(segment1a, 6, segment1b, 5);
|
||||
if(u_strcmp(chars, result1)) {
|
||||
log_err("Failure in multisegment 1\n");
|
||||
}
|
||||
free(chars);
|
||||
|
||||
chars = segment_test(segment2a, 6, segment2b, 5);
|
||||
if(u_strcmp(chars, result2)) {
|
||||
log_err("Failure in multisegment 2\n");
|
||||
}
|
||||
free(chars);
|
||||
|
||||
chars = segment_test(segment3a, 3, segment3b, 1);
|
||||
if(u_strcmp(chars, result3)) {
|
||||
log_err("Failure in multisegment 3\n");
|
||||
}
|
||||
free(chars);
|
||||
|
||||
/* register to handle interrupts */
|
||||
/*signal(SIGHUP, signal_handler);*/
|
||||
/*signal(SIGINT, signal_handler);*/
|
||||
|
|
@ -695,7 +830,8 @@ int TestSCSU()
|
|||
return 0;
|
||||
}
|
||||
|
||||
void addSUSCTest(TestNode** root)
|
||||
void
|
||||
addSUSCTest(TestNode** root)
|
||||
{
|
||||
addTest(root, &TestSCSU, "scsutest/TestSCSU");
|
||||
addTest(root, &TestSCSU, "scsutest/TestSCSU");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -304,7 +304,7 @@ void UnicodeTest::TestUnicodeData()
|
|||
char path[256];
|
||||
|
||||
strcpy(path , icu_getDefaultDataDirectory());
|
||||
strcat(path, "UnicodeData-3.0.0.beta.txt");
|
||||
strcat(path, "UnicodeData-3.0.0.txt");
|
||||
|
||||
input = fopen( path, "r");
|
||||
#ifdef WIN32
|
||||
|
|
@ -353,7 +353,7 @@ void UnicodeTest::TestUnicodeData()
|
|||
int32_t UnicodeTest::MakeProp(char* str)
|
||||
{
|
||||
int32_t result = 0;
|
||||
char* matchPosition;
|
||||
const char* matchPosition;
|
||||
|
||||
matchPosition = strstr(tagStrings, str);
|
||||
if (matchPosition == 0) errln((UnicodeString)"unrecognized type letter " + str);
|
||||
|
|
|
|||
|
|
@ -92,13 +92,14 @@ CharTypeBuilder::getByteArray(FILE* input)
|
|||
if (unicode == LAST_CHAR_CODE_IN_FILE)
|
||||
break;
|
||||
}
|
||||
/* Check the database to see if this needs to be updated!!! */
|
||||
ucmp8_setRange(charTypeArray, 0x3401, 0x4db4, ucmp8_get(charTypeArray, 0x3400));
|
||||
ucmp8_setRange(charTypeArray, 0x4e01, 0x9fa4, ucmp8_get(charTypeArray, 0x4e00));
|
||||
ucmp8_setRange(charTypeArray, 0xac01, 0xd7a2, ucmp8_get(charTypeArray, 0xac00));
|
||||
ucmp8_setRange(charTypeArray, 0xd801, 0xdb7e, ucmp8_get(charTypeArray, 0xd800));
|
||||
ucmp8_setRange(charTypeArray, 0xdb81, 0xdbfe, ucmp8_get(charTypeArray, 0xdb80));
|
||||
ucmp8_setRange(charTypeArray, 0xdc01, 0xdffe, ucmp8_get(charTypeArray, 0xdc00));
|
||||
ucmp8_setRange(charTypeArray, 0xe001, 0xf8fe, ucmp8_get(charTypeArray, 0xe000));
|
||||
ucmp8_setRange(charTypeArray, 0xf901, 0xfa2c, ucmp8_get(charTypeArray, 0xf900));
|
||||
|
||||
if (input) fclose(input);
|
||||
ucmp8_compact(charTypeArray, 1);
|
||||
|
|
|
|||
|
|
@ -414,7 +414,7 @@ void loadSBCSTableFromFile(FileStream* convFile, UConverter* myConverter, UError
|
|||
}
|
||||
|
||||
/*create a compact array with replacement chars as default chars*/
|
||||
myFromUnicode = ucmp8_open((int8_t)replacementChar);
|
||||
myFromUnicode = ucmp8_open(0);
|
||||
if (myFromUnicode == NULL)
|
||||
{
|
||||
icu_free(myConverterTable);
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue