531 lines
20 KiB
C++
531 lines
20 KiB
C++
/*
|
|
******************************************************************************
|
|
*
|
|
* © 2016 and later: Unicode, Inc. and others.
|
|
* License & terms of use: http://www.unicode.org/copyright.html
|
|
*
|
|
******************************************************************************
|
|
* file name: ubiditransform.c
|
|
* encoding: UTF-8
|
|
* tab size: 8 (not used)
|
|
* indentation:4
|
|
*
|
|
* created on: 2016jul24
|
|
* created by: Lina Kemmel
|
|
*
|
|
*/
|
|
|
|
#include "cmemory.h"
|
|
#include "unicode/ubidi.h"
|
|
#include "unicode/ustring.h"
|
|
#include "unicode/ushape.h"
|
|
#include "unicode/utf16.h"
|
|
#include "ustr_imp.h"
|
|
#include "unicode/ubiditransform.h"
|
|
|
|
/* Some convenience defines */
|
|
#define LTR UBIDI_LTR
|
|
#define RTL UBIDI_RTL
|
|
#define LOGICAL UBIDI_LOGICAL
|
|
#define VISUAL UBIDI_VISUAL
|
|
#define SHAPE_LOGICAL U_SHAPE_TEXT_DIRECTION_LOGICAL
|
|
#define SHAPE_VISUAL U_SHAPE_TEXT_DIRECTION_VISUAL_LTR
|
|
|
|
#define CHECK_LEN(STR, LEN, ERROR) UPRV_BLOCK_MACRO_BEGIN { \
|
|
if (LEN == 0) return 0; \
|
|
if (LEN < -1) { *(ERROR) = U_ILLEGAL_ARGUMENT_ERROR; return 0; } \
|
|
if (LEN == -1) LEN = u_strlen(STR); \
|
|
} UPRV_BLOCK_MACRO_END
|
|
|
|
#define MAX_ACTIONS 7
|
|
|
|
/**
|
|
* Typedef for a pointer to a function, which performs some operation (such as
|
|
* reordering, setting "inverse" mode, character mirroring, etc.). Return value
|
|
* indicates whether the text was changed in the course of this operation or
|
|
* not.
|
|
*/
|
|
typedef UBool (*UBiDiAction)(UBiDiTransform *, UErrorCode *);
|
|
|
|
/**
|
|
* Structure that holds a predefined reordering scheme, including the following
|
|
* information:
|
|
* <ul>
|
|
* <li>an input base direction,</li>
|
|
* <li>an input order,</li>
|
|
* <li>an output base direction,</li>
|
|
* <li>an output order,</li>
|
|
* <li>a digit shaping direction,</li>
|
|
* <li>a letter shaping direction,</li>
|
|
* <li>a base direction that should be applied when the reordering engine is
|
|
* invoked (which can not always be derived from the caller-defined
|
|
* options),</li>
|
|
* <li>an array of pointers to functions that accomplish the bidi layout
|
|
* transformation.</li>
|
|
* </ul>
|
|
*/
|
|
typedef struct {
|
|
UBiDiLevel inLevel; /* input level */
|
|
UBiDiOrder inOrder; /* input order */
|
|
UBiDiLevel outLevel; /* output level */
|
|
UBiDiOrder outOrder; /* output order */
|
|
uint32_t digitsDir; /* digit shaping direction */
|
|
uint32_t lettersDir; /* letter shaping direction */
|
|
UBiDiLevel baseLevel; /* paragraph level to be used with setPara */
|
|
const UBiDiAction actions[MAX_ACTIONS]; /* array of pointers to functions carrying out the transformation */
|
|
} ReorderingScheme;
|
|
|
|
struct UBiDiTransform {
|
|
UBiDi *pBidi; /* pointer to a UBiDi object */
|
|
const ReorderingScheme *pActiveScheme; /* effective reordering scheme */
|
|
UChar *src; /* input text */
|
|
UChar *dest; /* output text */
|
|
uint32_t srcLength; /* input text length - not really needed as we are zero-terminated and can u_strlen */
|
|
uint32_t srcSize; /* input text capacity excluding the trailing zero */
|
|
uint32_t destSize; /* output text capacity */
|
|
uint32_t *pDestLength; /* number of UChars written to dest */
|
|
uint32_t reorderingOptions; /* reordering options - currently only suppot DO_MIRRORING */
|
|
uint32_t digits; /* digit option for ArabicShaping */
|
|
uint32_t letters; /* letter option for ArabicShaping */
|
|
};
|
|
|
|
U_CAPI UBiDiTransform* U_EXPORT2
|
|
ubiditransform_open(UErrorCode *pErrorCode)
|
|
{
|
|
UBiDiTransform *pBiDiTransform = NULL;
|
|
if (U_SUCCESS(*pErrorCode)) {
|
|
pBiDiTransform = (UBiDiTransform*) uprv_calloc(1, sizeof(UBiDiTransform));
|
|
if (pBiDiTransform == NULL) {
|
|
*pErrorCode = U_MEMORY_ALLOCATION_ERROR;
|
|
}
|
|
}
|
|
return pBiDiTransform;
|
|
}
|
|
|
|
U_CAPI void U_EXPORT2
|
|
ubiditransform_close(UBiDiTransform *pBiDiTransform)
|
|
{
|
|
if (pBiDiTransform != NULL) {
|
|
if (pBiDiTransform->pBidi != NULL) {
|
|
ubidi_close(pBiDiTransform->pBidi);
|
|
}
|
|
if (pBiDiTransform->src != NULL) {
|
|
uprv_free(pBiDiTransform->src);
|
|
}
|
|
uprv_free(pBiDiTransform);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Performs Bidi resolution of text.
|
|
*
|
|
* @param pTransform Pointer to the <code>UBiDiTransform</code> structure.
|
|
* @param pErrorCode Pointer to the error code value.
|
|
*
|
|
* @return Whether or not this function modifies the text. Besides the return
|
|
* value, the caller should also check <code>U_SUCCESS(*pErrorCode)</code>.
|
|
*/
|
|
static UBool
|
|
action_resolve(UBiDiTransform *pTransform, UErrorCode *pErrorCode)
|
|
{
|
|
ubidi_setPara(pTransform->pBidi, pTransform->src, pTransform->srcLength,
|
|
pTransform->pActiveScheme->baseLevel, NULL, pErrorCode);
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Performs basic reordering of text (Logical -> Visual LTR).
|
|
*
|
|
* @param pTransform Pointer to the <code>UBiDiTransform</code> structure.
|
|
* @param pErrorCode Pointer to the error code value.
|
|
*
|
|
* @return Whether or not this function modifies the text. Besides the return
|
|
* value, the caller should also check <code>U_SUCCESS(*pErrorCode)</code>.
|
|
*/
|
|
static UBool
|
|
action_reorder(UBiDiTransform *pTransform, UErrorCode *pErrorCode)
|
|
{
|
|
ubidi_writeReordered(pTransform->pBidi, pTransform->dest, pTransform->destSize,
|
|
static_cast<uint16_t>(pTransform->reorderingOptions), pErrorCode);
|
|
|
|
*pTransform->pDestLength = pTransform->srcLength;
|
|
pTransform->reorderingOptions = UBIDI_REORDER_DEFAULT;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Sets "inverse" mode on the <code>UBiDi</code> object.
|
|
*
|
|
* @param pTransform Pointer to the <code>UBiDiTransform</code> structure.
|
|
* @param pErrorCode Pointer to the error code value.
|
|
*
|
|
* @return Whether or not this function modifies the text. Besides the return
|
|
* value, the caller should also check <code>U_SUCCESS(*pErrorCode)</code>.
|
|
*/
|
|
static UBool
|
|
action_setInverse(UBiDiTransform *pTransform, UErrorCode *pErrorCode)
|
|
{
|
|
(void)pErrorCode;
|
|
ubidi_setInverse(pTransform->pBidi, true);
|
|
ubidi_setReorderingMode(pTransform->pBidi, UBIDI_REORDER_INVERSE_LIKE_DIRECT);
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Sets "runs only" reordering mode indicating a Logical LTR <-> Logical RTL
|
|
* transformation.
|
|
*
|
|
* @param pTransform Pointer to the <code>UBiDiTransform</code> structure.
|
|
* @param pErrorCode Pointer to the error code value.
|
|
*
|
|
* @return Whether or not this function modifies the text. Besides the return
|
|
* value, the caller should also check <code>U_SUCCESS(*pErrorCode)</code>.
|
|
*/
|
|
static UBool
|
|
action_setRunsOnly(UBiDiTransform *pTransform, UErrorCode *pErrorCode)
|
|
{
|
|
(void)pErrorCode;
|
|
ubidi_setReorderingMode(pTransform->pBidi, UBIDI_REORDER_RUNS_ONLY);
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Performs string reverse.
|
|
*
|
|
* @param pTransform Pointer to the <code>UBiDiTransform</code> structure.
|
|
* @param pErrorCode Pointer to the error code value.
|
|
*
|
|
* @return Whether or not this function modifies the text. Besides the return
|
|
* value, the caller should also check <code>U_SUCCESS(*pErrorCode)</code>.
|
|
*/
|
|
static UBool
|
|
action_reverse(UBiDiTransform *pTransform, UErrorCode *pErrorCode)
|
|
{
|
|
ubidi_writeReverse(pTransform->src, pTransform->srcLength,
|
|
pTransform->dest, pTransform->destSize,
|
|
UBIDI_REORDER_DEFAULT, pErrorCode);
|
|
*pTransform->pDestLength = pTransform->srcLength;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Applies a new value to the text that serves as input at the current
|
|
* processing step. This value is identical to the original one when we begin
|
|
* the processing, but usually changes as the transformation progresses.
|
|
*
|
|
* @param pTransform A pointer to the <code>UBiDiTransform</code> structure.
|
|
* @param newSrc A pointer whose value is to be used as input text.
|
|
* @param newLength A length of the new text in <code>UChar</code>s.
|
|
* @param newSize A new source capacity in <code>UChar</code>s.
|
|
* @param pErrorCode Pointer to the error code value.
|
|
*/
|
|
static void
|
|
updateSrc(UBiDiTransform *pTransform, const UChar *newSrc, uint32_t newLength,
|
|
uint32_t newSize, UErrorCode *pErrorCode)
|
|
{
|
|
if (newSize < newLength) {
|
|
*pErrorCode = U_BUFFER_OVERFLOW_ERROR;
|
|
return;
|
|
}
|
|
if (newSize > pTransform->srcSize) {
|
|
newSize += 50; // allocate slightly more than needed right now
|
|
if (pTransform->src != NULL) {
|
|
uprv_free(pTransform->src);
|
|
pTransform->src = NULL;
|
|
}
|
|
pTransform->src = (UChar *)uprv_malloc(newSize * sizeof(UChar));
|
|
if (pTransform->src == NULL) {
|
|
*pErrorCode = U_MEMORY_ALLOCATION_ERROR;
|
|
//pTransform->srcLength = pTransform->srcSize = 0;
|
|
return;
|
|
}
|
|
pTransform->srcSize = newSize;
|
|
}
|
|
u_strncpy(pTransform->src, newSrc, newLength);
|
|
pTransform->srcLength = u_terminateUChars(pTransform->src,
|
|
pTransform->srcSize, newLength, pErrorCode);
|
|
}
|
|
|
|
/**
|
|
* Calls a lower level shaping function.
|
|
*
|
|
* @param pTransform Pointer to the <code>UBiDiTransform</code> structure.
|
|
* @param options Shaping options.
|
|
* @param pErrorCode Pointer to the error code value.
|
|
*/
|
|
static void
|
|
doShape(UBiDiTransform *pTransform, uint32_t options, UErrorCode *pErrorCode)
|
|
{
|
|
*pTransform->pDestLength = u_shapeArabic(pTransform->src,
|
|
pTransform->srcLength, pTransform->dest, pTransform->destSize,
|
|
options, pErrorCode);
|
|
}
|
|
|
|
/**
|
|
* Performs digit and letter shaping.
|
|
*
|
|
* @param pTransform Pointer to the <code>UBiDiTransform</code> structure.
|
|
* @param pErrorCode Pointer to the error code value.
|
|
*
|
|
* @return Whether or not this function modifies the text. Besides the return
|
|
* value, the caller should also check <code>U_SUCCESS(*pErrorCode)</code>.
|
|
*/
|
|
static UBool
|
|
action_shapeArabic(UBiDiTransform *pTransform, UErrorCode *pErrorCode)
|
|
{
|
|
if ((pTransform->letters | pTransform->digits) == 0) {
|
|
return false;
|
|
}
|
|
if (pTransform->pActiveScheme->lettersDir == pTransform->pActiveScheme->digitsDir) {
|
|
doShape(pTransform, pTransform->letters | pTransform->digits | pTransform->pActiveScheme->lettersDir,
|
|
pErrorCode);
|
|
} else {
|
|
doShape(pTransform, pTransform->digits | pTransform->pActiveScheme->digitsDir, pErrorCode);
|
|
if (U_SUCCESS(*pErrorCode)) {
|
|
updateSrc(pTransform, pTransform->dest, *pTransform->pDestLength,
|
|
*pTransform->pDestLength, pErrorCode);
|
|
doShape(pTransform, pTransform->letters | pTransform->pActiveScheme->lettersDir,
|
|
pErrorCode);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Performs character mirroring.
|
|
*
|
|
* @param pTransform Pointer to the <code>UBiDiTransform</code> structure.
|
|
* @param pErrorCode Pointer to the error code value.
|
|
*
|
|
* @return Whether or not this function modifies the text. Besides the return
|
|
* value, the caller should also check <code>U_SUCCESS(*pErrorCode)</code>.
|
|
*/
|
|
static UBool
|
|
action_mirror(UBiDiTransform *pTransform, UErrorCode *pErrorCode)
|
|
{
|
|
UChar32 c;
|
|
uint32_t i = 0, j = 0;
|
|
if (0 == (pTransform->reorderingOptions & UBIDI_DO_MIRRORING)) {
|
|
return false;
|
|
}
|
|
if (pTransform->destSize < pTransform->srcLength) {
|
|
*pErrorCode = U_BUFFER_OVERFLOW_ERROR;
|
|
return false;
|
|
}
|
|
do {
|
|
UBool isOdd = ubidi_getLevelAt(pTransform->pBidi, i) & 1;
|
|
U16_NEXT(pTransform->src, i, pTransform->srcLength, c);
|
|
U16_APPEND_UNSAFE(pTransform->dest, j, isOdd ? u_charMirror(c) : c);
|
|
} while (i < pTransform->srcLength);
|
|
|
|
*pTransform->pDestLength = pTransform->srcLength;
|
|
pTransform->reorderingOptions = UBIDI_REORDER_DEFAULT;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* All possible reordering schemes.
|
|
*
|
|
*/
|
|
static const ReorderingScheme Schemes[] =
|
|
{
|
|
/* 0: Logical LTR => Visual LTR */
|
|
{LTR, LOGICAL, LTR, VISUAL, SHAPE_LOGICAL, SHAPE_LOGICAL, LTR,
|
|
{action_shapeArabic, action_resolve, action_reorder, NULL}},
|
|
/* 1: Logical RTL => Visual LTR */
|
|
{RTL, LOGICAL, LTR, VISUAL, SHAPE_LOGICAL, SHAPE_VISUAL, RTL,
|
|
{action_resolve, action_reorder, action_shapeArabic, NULL}},
|
|
/* 2: Logical LTR => Visual RTL */
|
|
{LTR, LOGICAL, RTL, VISUAL, SHAPE_LOGICAL, SHAPE_LOGICAL, LTR,
|
|
{action_shapeArabic, action_resolve, action_reorder, action_reverse, NULL}},
|
|
/* 3: Logical RTL => Visual RTL */
|
|
{RTL, LOGICAL, RTL, VISUAL, SHAPE_LOGICAL, SHAPE_VISUAL, RTL,
|
|
{action_resolve, action_reorder, action_shapeArabic, action_reverse, NULL}},
|
|
/* 4: Visual LTR => Logical RTL */
|
|
{LTR, VISUAL, RTL, LOGICAL, SHAPE_LOGICAL, SHAPE_VISUAL, RTL,
|
|
{action_shapeArabic, action_setInverse, action_resolve, action_reorder, NULL}},
|
|
/* 5: Visual RTL => Logical RTL */
|
|
{RTL, VISUAL, RTL, LOGICAL, SHAPE_LOGICAL, SHAPE_VISUAL, RTL,
|
|
{action_reverse, action_shapeArabic, action_setInverse, action_resolve, action_reorder, NULL}},
|
|
/* 6: Visual LTR => Logical LTR */
|
|
{LTR, VISUAL, LTR, LOGICAL, SHAPE_LOGICAL, SHAPE_LOGICAL, LTR,
|
|
{action_setInverse, action_resolve, action_reorder, action_shapeArabic, NULL}},
|
|
/* 7: Visual RTL => Logical LTR */
|
|
{RTL, VISUAL, LTR, LOGICAL, SHAPE_LOGICAL, SHAPE_LOGICAL, LTR,
|
|
{action_reverse, action_setInverse, action_resolve, action_reorder, action_shapeArabic, NULL}},
|
|
/* 8: Logical LTR => Logical RTL */
|
|
{LTR, LOGICAL, RTL, LOGICAL, SHAPE_LOGICAL, SHAPE_LOGICAL, LTR,
|
|
{action_shapeArabic, action_resolve, action_mirror, action_setRunsOnly, action_resolve, action_reorder, NULL}},
|
|
/* 9: Logical RTL => Logical LTR */
|
|
{RTL, LOGICAL, LTR, LOGICAL, SHAPE_LOGICAL, SHAPE_LOGICAL, RTL,
|
|
{action_resolve, action_mirror, action_setRunsOnly, action_resolve, action_reorder, action_shapeArabic, NULL}},
|
|
/* 10: Visual LTR => Visual RTL */
|
|
{LTR, VISUAL, RTL, VISUAL, SHAPE_LOGICAL, SHAPE_VISUAL, LTR,
|
|
{action_shapeArabic, action_setInverse, action_resolve, action_mirror, action_reverse, NULL}},
|
|
/* 11: Visual RTL => Visual LTR */
|
|
{RTL, VISUAL, LTR, VISUAL, SHAPE_LOGICAL, SHAPE_VISUAL, LTR,
|
|
{action_reverse, action_shapeArabic, action_setInverse, action_resolve, action_mirror, NULL}},
|
|
/* 12: Logical LTR => Logical LTR */
|
|
{LTR, LOGICAL, LTR, LOGICAL, SHAPE_LOGICAL, SHAPE_LOGICAL, LTR,
|
|
{action_resolve, action_mirror, action_shapeArabic, NULL}},
|
|
/* 13: Logical RTL => Logical RTL */
|
|
{RTL, LOGICAL, RTL, LOGICAL, SHAPE_VISUAL, SHAPE_LOGICAL, RTL,
|
|
{action_resolve, action_mirror, action_shapeArabic, NULL}},
|
|
/* 14: Visual LTR => Visual LTR */
|
|
{LTR, VISUAL, LTR, VISUAL, SHAPE_LOGICAL, SHAPE_VISUAL, LTR,
|
|
{action_resolve, action_mirror, action_shapeArabic, NULL}},
|
|
/* 15: Visual RTL => Visual RTL */
|
|
{RTL, VISUAL, RTL, VISUAL, SHAPE_LOGICAL, SHAPE_VISUAL, LTR,
|
|
{action_reverse, action_resolve, action_mirror, action_shapeArabic, action_reverse, NULL}}
|
|
};
|
|
|
|
static const uint32_t nSchemes = sizeof(Schemes) / sizeof(*Schemes);
|
|
|
|
/**
|
|
* When the direction option is <code>UBIDI_DEFAULT_LTR</code> or
|
|
* <code>UBIDI_DEFAULT_RTL</code>, resolve the base direction according to that
|
|
* of the first strong bidi character.
|
|
*/
|
|
static void
|
|
resolveBaseDirection(const UChar *text, uint32_t length,
|
|
UBiDiLevel *pInLevel, UBiDiLevel *pOutLevel)
|
|
{
|
|
switch (*pInLevel) {
|
|
case UBIDI_DEFAULT_LTR:
|
|
case UBIDI_DEFAULT_RTL: {
|
|
UBiDiLevel level = static_cast<UBiDiLevel>(ubidi_getBaseDirection(text, length));
|
|
*pInLevel = static_cast<UBiDiLevel>(level != UBIDI_NEUTRAL) ? level
|
|
: *pInLevel == UBIDI_DEFAULT_RTL ? static_cast<UBiDiLevel>(RTL) : static_cast<UBiDiLevel>(LTR);
|
|
break;
|
|
}
|
|
default:
|
|
*pInLevel &= 1;
|
|
break;
|
|
}
|
|
switch (*pOutLevel) {
|
|
case UBIDI_DEFAULT_LTR:
|
|
case UBIDI_DEFAULT_RTL:
|
|
*pOutLevel = *pInLevel;
|
|
break;
|
|
default:
|
|
*pOutLevel &= 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Finds a valid <code>ReorderingScheme</code> matching the
|
|
* caller-defined scheme.
|
|
*
|
|
* @return A valid <code>ReorderingScheme</code> object or NULL
|
|
*/
|
|
static const ReorderingScheme*
|
|
findMatchingScheme(UBiDiLevel inLevel, UBiDiLevel outLevel,
|
|
UBiDiOrder inOrder, UBiDiOrder outOrder)
|
|
{
|
|
uint32_t i;
|
|
for (i = 0; i < nSchemes; i++) {
|
|
const ReorderingScheme *pScheme = Schemes + i;
|
|
if (inLevel == pScheme->inLevel && outLevel == pScheme->outLevel
|
|
&& inOrder == pScheme->inOrder && outOrder == pScheme->outOrder) {
|
|
return pScheme;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
U_CAPI uint32_t U_EXPORT2
|
|
ubiditransform_transform(UBiDiTransform *pBiDiTransform,
|
|
const UChar *src, int32_t srcLength,
|
|
UChar *dest, int32_t destSize,
|
|
UBiDiLevel inParaLevel, UBiDiOrder inOrder,
|
|
UBiDiLevel outParaLevel, UBiDiOrder outOrder,
|
|
UBiDiMirroring doMirroring, uint32_t shapingOptions,
|
|
UErrorCode *pErrorCode)
|
|
{
|
|
uint32_t destLength = 0;
|
|
UBool textChanged = false;
|
|
const UBiDiTransform *pOrigTransform = pBiDiTransform;
|
|
const UBiDiAction *action = NULL;
|
|
|
|
if (U_FAILURE(*pErrorCode)) {
|
|
return 0;
|
|
}
|
|
if (src == NULL || dest == NULL) {
|
|
*pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
|
|
return 0;
|
|
}
|
|
CHECK_LEN(src, srcLength, pErrorCode);
|
|
CHECK_LEN(dest, destSize, pErrorCode);
|
|
|
|
if (pBiDiTransform == NULL) {
|
|
pBiDiTransform = ubiditransform_open(pErrorCode);
|
|
if (U_FAILURE(*pErrorCode)) {
|
|
return 0;
|
|
}
|
|
}
|
|
/* Current limitation: in multiple paragraphs will be resolved according
|
|
to the 1st paragraph */
|
|
resolveBaseDirection(src, srcLength, &inParaLevel, &outParaLevel);
|
|
|
|
pBiDiTransform->pActiveScheme = findMatchingScheme(inParaLevel, outParaLevel,
|
|
inOrder, outOrder);
|
|
if (pBiDiTransform->pActiveScheme == NULL) {
|
|
goto cleanup;
|
|
}
|
|
pBiDiTransform->reorderingOptions = doMirroring ? UBIDI_DO_MIRRORING
|
|
: UBIDI_REORDER_DEFAULT;
|
|
|
|
/* Ignore TEXT_DIRECTION_* flags, as we apply our own depending on the text
|
|
scheme at the time shaping is invoked. */
|
|
shapingOptions &= ~U_SHAPE_TEXT_DIRECTION_MASK;
|
|
pBiDiTransform->digits = shapingOptions & ~U_SHAPE_LETTERS_MASK;
|
|
pBiDiTransform->letters = shapingOptions & ~U_SHAPE_DIGITS_MASK;
|
|
|
|
updateSrc(pBiDiTransform, src, srcLength, destSize > srcLength ? destSize : srcLength, pErrorCode);
|
|
if (U_FAILURE(*pErrorCode)) {
|
|
goto cleanup;
|
|
}
|
|
if (pBiDiTransform->pBidi == NULL) {
|
|
pBiDiTransform->pBidi = ubidi_openSized(0, 0, pErrorCode);
|
|
if (U_FAILURE(*pErrorCode)) {
|
|
goto cleanup;
|
|
}
|
|
}
|
|
pBiDiTransform->dest = dest;
|
|
pBiDiTransform->destSize = destSize;
|
|
pBiDiTransform->pDestLength = &destLength;
|
|
|
|
/* Checking for U_SUCCESS() within the loop to bail out on first failure. */
|
|
for (action = pBiDiTransform->pActiveScheme->actions; *action && U_SUCCESS(*pErrorCode); action++) {
|
|
if ((*action)(pBiDiTransform, pErrorCode)) {
|
|
if (action + 1) {
|
|
updateSrc(pBiDiTransform, pBiDiTransform->dest, *pBiDiTransform->pDestLength,
|
|
*pBiDiTransform->pDestLength, pErrorCode);
|
|
}
|
|
textChanged = true;
|
|
}
|
|
}
|
|
ubidi_setInverse(pBiDiTransform->pBidi, false);
|
|
|
|
if (!textChanged && U_SUCCESS(*pErrorCode)) {
|
|
/* Text was not changed - just copy src to dest */
|
|
if (destSize < srcLength) {
|
|
*pErrorCode = U_BUFFER_OVERFLOW_ERROR;
|
|
} else {
|
|
u_strncpy(dest, src, srcLength);
|
|
destLength = srcLength;
|
|
}
|
|
}
|
|
cleanup:
|
|
if (pOrigTransform != pBiDiTransform) {
|
|
ubiditransform_close(pBiDiTransform);
|
|
} else {
|
|
pBiDiTransform->dest = NULL;
|
|
pBiDiTransform->pDestLength = NULL;
|
|
pBiDiTransform->srcLength = 0;
|
|
pBiDiTransform->destSize = 0;
|
|
}
|
|
return U_FAILURE(*pErrorCode) ? 0 : destLength;
|
|
}
|