bidi.c File Reference

#include <stdarg.h>
#include <stdlib.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winnls.h"
#include "usp10.h"
#include "wine/debug.h"
#include "wine/heap.h"
#include "wine/list.h"
#include "usp10_internal.h"

Include dependency graph for bidi.c:

Go to the source code of this file.

Classes
struct	tagStackItem
struct	tagRun
struct	tagRunChar
struct	tagIsolatedRun
struct	tagBracketPair

Macros
#define	ASSERT(x)   do { if (!(x)) FIXME("assert failed: %s\n", #x); } while(0)
#define	MAX_DEPTH   125
#define	push_stack(l, o, i)
#define	pop_stack()   do { stack_top++; } while(0)
#define	valid_level(x)   (x <= MAX_DEPTH && overflow_isolate_count == 0 && overflow_embedding_count == 0)
#define	N0_TYPE(a)   ((a == AN || a == EN)?R:a)

Typedefs
typedef struct tagStackItem	StackItem
typedef struct tagRun	Run
typedef struct tagRunChar	RunChar
typedef struct tagIsolatedRun	IsolatedRun
typedef struct tagBracketPair	BracketPair

Enumerations
enum	directions {   ON = 0 , L , R , AN ,   EN , AL , NSM , CS ,   ES , ET , BN , S ,   WS , B , RLO , RLE ,   LRO , LRE , PDF , LRI ,   RLI , FSI , PDI , NI = ON ,   ON = 0 , L , R , AN ,   EN , AL , NSM , CS ,   ES , ET , BN , S ,   WS , B , RLO , RLE ,   LRO , LRE , PDF , LRI ,   RLI , FSI , PDI , NI = ON }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (bidi)
static void	dump_types (const char *header, WORD *types, int start, int end)
static void	classify (const WCHAR *string, WORD *chartype, DWORD count, const SCRIPT_CONTROL *c)
static WORD	GreaterEven (int i)
static WORD	GreaterOdd (int i)
static WORD	EmbeddingDirection (int level)
static void	resolveExplicit (int level, WORD *pclass, WORD *poutLevel, WORD *poutOverrides, int count, BOOL initialOverride)
static int	previousValidChar (const WORD *pcls, int index, int back_fence)
static int	nextValidChar (const WORD *pcls, int index, int front_fence)
static int	iso_nextValidChar (IsolatedRun *iso_run, int index)
static int	iso_previousValidChar (IsolatedRun *iso_run, int index)
static void	iso_dump_types (const char *header, IsolatedRun *iso_run)
static void	resolveWeak (IsolatedRun *iso_run)
static int __cdecl	compr (const void *a, const void *b)
static BracketPair *	computeBracketPairs (IsolatedRun *iso_run)
static void	resolveNeutrals (IsolatedRun *iso_run)
static void	resolveImplicit (const WORD *pcls, WORD *plevel, int sos, int eos)
static void	resolveResolved (unsigned baselevel, const WORD *pcls, WORD *plevel, int sos, int eos)
static void	computeIsolatingRunsSet (unsigned baselevel, WORD *pcls, const WORD *pLevel, const WCHAR *string, unsigned int uCount, struct list *set)
BOOL	BIDI_DetermineLevels (const WCHAR *lpString, unsigned int uCount, const SCRIPT_STATE *s, const SCRIPT_CONTROL *c, WORD *lpOutLevels, WORD *lpOutOverrides)
static void	reverse (int *pidx, int cch)
int	BIDI_ReorderV2lLevel (int level, int *pIndexs, const BYTE *plevel, int cch, BOOL fReverse)
int	BIDI_ReorderL2vLevel (int level, int *pIndexs, const BYTE *plevel, int cch, BOOL fReverse)
BOOL	BIDI_GetStrengths (const WCHAR *string, unsigned int count, const SCRIPT_CONTROL *c, WORD *strength)

Variables
const unsigned short bidi_bracket_table[]	DECLSPEC_HIDDEN
static const char	debug_type [][4]

Macro Definition Documentation

ASSERT

#define ASSERT

(

x

)

do { if (!(x)) FIXME("assert failed: %s\n", #x); } while(0)

Definition at line 62 of file bidi.c.

MAX_DEPTH

#define MAX_DEPTH   125

Definition at line 63 of file bidi.c.

N0_TYPE

#define N0_TYPE

(

a

)

((a == AN || a == EN)?R:a)

Definition at line 714 of file bidi.c.

pop_stack

#define pop_stack

(

)

do { stack_top++; } while(0)

Definition at line 223 of file bidi.c.

push_stack

#define push_stack	(		l,
			o,
			i
	)

Value:

  do { stack_top--; \
  stack[stack_top].level = l; \
  stack[stack_top].override = o; \
  stack[stack_top].isolate = i;} while(0)

Definition at line 217 of file bidi.c.

valid_level

#define valid_level

(

x

)

(x <= MAX_DEPTH && overflow_isolate_count == 0 && overflow_embedding_count == 0)

Definition at line 225 of file bidi.c.

Typedef Documentation

BracketPair

typedef struct tagBracketPair BracketPair

IsolatedRun

typedef struct tagIsolatedRun IsolatedRun

Run

typedef struct tagRun Run

RunChar

typedef struct tagRunChar RunChar

StackItem

typedef struct tagStackItem StackItem

Enumeration Type Documentation

directions

enum directions

Enumerator
ON
L
R
AN
EN
AL
NSM
CS
ES
ET
BN
S
WS
B
RLO
RLE
LRO
LRE
PDF
LRI
RLI
FSI
PDI
NI
ON
L
R
AN
EN
AL
NSM
CS
ES
ET
BN
S
WS
B
RLO
RLE
LRO
LRE
PDF
LRI
RLI
FSI
PDI
NI

Definition at line 78 of file bidi.c.

{
    /* input types */
             /* ON MUST be zero, code relies on ON = NI = 0 */
    ON = 0,  /* Other Neutral */
    L,       /* Left Letter */
    R,       /* Right Letter */
    AN,      /* Arabic Number */
    EN,      /* European Number */
    AL,      /* Arabic Letter (Right-to-left) */
    NSM,     /* Non-spacing Mark */
    CS,      /* Common Separator */
    ES,      /* European Separator */
    ET,      /* European Terminator (post/prefix e.g. $ and %) */
 
    /* resolved types */
    BN,      /* Boundary neutral (type of RLE etc after explicit levels) */
 
    /* input types, */
    S,       /* Segment Separator (TAB)        // used only in L1 */
    WS,      /* White space                    // used only in L1 */
    B,       /* Paragraph Separator (aka as PS) */
 
    /* types for explicit controls */
    RLO,     /* these are used only in X1-X9 */
    RLE,
    LRO,
    LRE,
    PDF,
 
    LRI, /* Isolate formatting characters new with 6.3 */
    RLI,
    FSI,
    PDI,
 
    /* resolved types, also resolved directions */
    NI = ON,  /* alias, where ON, WS, S  and Isolates are treated the same */
};

Function Documentation

BIDI_DetermineLevels()

BOOL BIDI_DetermineLevels	(	const WCHAR *	lpString,
		unsigned int	uCount,
		const SCRIPT_STATE *	s,
		const SCRIPT_CONTROL *	c,
		WORD *	lpOutLevels,
		WORD *	lpOutOverrides
	)

Definition at line 1088 of file bidi.c.

{
    WORD *chartype;
    unsigned baselevel = 0;
    struct list IsolatingRuns;
    IsolatedRun *iso_run, *next;
 
    TRACE("%s, %d\n", debugstr_wn(lpString, uCount), uCount);
 
    if (!(chartype = heap_alloc(uCount * sizeof(*chartype))))
    {
        WARN("Out of memory\n");
        return FALSE;
    }
 
    baselevel = s->uBidiLevel;
 
    classify(lpString, chartype, uCount, c);
    if (TRACE_ON(bidi)) dump_types("Start ", chartype, 0, uCount);
 
    memset(lpOutOverrides, 0, sizeof(WORD) * uCount);
 
    /* resolve explicit */
    resolveExplicit(baselevel, chartype, lpOutLevels, lpOutOverrides, uCount, s->fOverrideDirection);
    if (TRACE_ON(bidi)) dump_types("After Explicit", chartype, 0, uCount);
 
    /* X10/BD13: Computer Isolating runs */
    computeIsolatingRunsSet(baselevel, chartype, lpOutLevels, lpString, uCount, &IsolatingRuns);
 
    LIST_FOR_EACH_ENTRY_SAFE(iso_run, next, &IsolatingRuns, IsolatedRun, entry)
    {
        if (TRACE_ON(bidi)) iso_dump_types("Run", iso_run);
 
        /* resolve weak */
        resolveWeak(iso_run);
        if (TRACE_ON(bidi)) iso_dump_types("After Weak", iso_run);
 
        /* resolve neutrals */
        resolveNeutrals(iso_run);
        if (TRACE_ON(bidi)) iso_dump_types("After Neutrals", iso_run);
 
        list_remove(&iso_run->entry);
        heap_free(iso_run);
    }
 
    if (TRACE_ON(bidi)) dump_types("Before Implicit", chartype, 0, uCount);
    /* resolveImplicit */
    resolveImplicit(chartype, lpOutLevels, 0, uCount-1);
 
    /* resolveResolvedLevels*/
    classify(lpString, chartype, uCount, c);
    resolveResolved(baselevel, chartype, lpOutLevels, 0, uCount-1);
 
    heap_free(chartype);
    return TRUE;
}

Referenced by _ItemizeInternal().

BIDI_GetStrengths()

BOOL BIDI_GetStrengths	(	const WCHAR *	string,
		unsigned int	count,
		const SCRIPT_CONTROL *	c,
		WORD *	strength
	)

Definition at line 1249 of file bidi.c.

{
    unsigned int i;
 
    classify(string, strength, count, c);
    for (i = 0; i < count; i++)
    {
        switch (strength[i])
        {
            case L:
            case LRE:
            case LRO:
            case R:
            case AL:
            case RLE:
            case RLO:
                strength[i] = BIDI_STRONG;
                break;
            case PDF:
            case EN:
            case ES:
            case ET:
            case AN:
            case CS:
            case BN:
                strength[i] = BIDI_WEAK;
                break;
            case B:
            case S:
            case WS:
            case ON:
            default: /* Neutrals and NSM */
                strength[i] = BIDI_NEUTRAL;
        }
    }
    return TRUE;
}

Referenced by _ItemizeInternal().

BIDI_ReorderL2vLevel()

int BIDI_ReorderL2vLevel	(	int	level,
		int *	pIndexs,
		const BYTE *	plevel,
		int	cch,
		BOOL	fReverse
	)

Definition at line 1215 of file bidi.c.

{
    int ich = 0;
    int newlevel = -1;
 
    /* true as soon as first odd level encountered */
    fReverse = fReverse || odd(level);
 
    for (; ich < cch; ich++)
    {
        if (plevel[ich] < level)
            break;
        else if (plevel[ich] > level)
            newlevel = ich;
    }
    if (fReverse)
    {
        reverse(pIndexs, ich);
    }
 
    if (newlevel >= 0)
    {
        ich = 0;
        for (; ich < cch; ich++)
            if (plevel[ich] < level)
                break;
            else if (plevel[ich] > level)
                ich += BIDI_ReorderL2vLevel(level + 1, pIndexs + ich, plevel + ich,
                cch - ich, fReverse) - 1;
    }
 
    return ich;
}

Referenced by BIDI_ReorderL2vLevel(), and ScriptLayout().

BIDI_ReorderV2lLevel()

int BIDI_ReorderV2lLevel	(	int	level,
		int *	pIndexs,
		const BYTE *	plevel,
		int	cch,
		BOOL	fReverse
	)

Definition at line 1188 of file bidi.c.

{
    int ich = 0;
 
    /* true as soon as first odd level encountered */
    fReverse = fReverse || odd(level);
 
    for (; ich < cch; ich++)
    {
        if (plevel[ich] < level)
        {
            break;
        }
        else if (plevel[ich] > level)
        {
            ich += BIDI_ReorderV2lLevel(level + 1, pIndexs + ich, plevel + ich,
                cch - ich, fReverse) - 1;
        }
    }
    if (fReverse)
    {
        reverse(pIndexs, ich);
    }
    return ich;
}

Referenced by BIDI_ReorderV2lLevel(), and ScriptLayout().

classify()

static void classify ( const WCHAR *  string, WORD *  chartype, DWORD  count, const SCRIPT_CONTROL *  c  )

static

Definition at line 161 of file bidi.c.

{
    unsigned i;
 
    for (i = 0; i < count; ++i)
    {
        chartype[i] = get_table_entry( bidi_direction_table, string[i] );
        if (c->fLegacyBidiClass && chartype[i] == ES)
        {
            if (string[i] == '+' || string[i] == '-') chartype[i] = NI;
        }
    }
}

compr()

static int __cdecl compr ( const void *  a, const void *  b  )

static

Definition at line 641 of file bidi.c.

{
    return ((BracketPair*)a)->start - ((BracketPair*)b)->start;
}

Referenced by BITMAP_LoadImageW(), computeBracketPairs(), create_alpha_bitmap(), CURSORICON_GetCursorDataFromBMI(), DIB_GetBitmapInfo(), GreGetDIBitsInternal(), pcf_get_metric(), and test_dib_formats().

computeBracketPairs()

static BracketPair * computeBracketPairs ( IsolatedRun *  iso_run )

static

Definition at line 646 of file bidi.c.

{
    WCHAR *open_stack;
    int *stack_index;
    int stack_top = iso_run->length;
    unsigned int pair_count = 0;
    BracketPair *out = NULL;
    SIZE_T out_size = 0;
    int i;
 
    open_stack = heap_alloc(iso_run->length * sizeof(*open_stack));
    stack_index = heap_alloc(iso_run->length * sizeof(*stack_index));
 
    for (i = 0; i < iso_run->length; i++)
    {
        unsigned short ubv = get_table_entry(bidi_bracket_table, iso_run->item[i].ch);
 
        if (!ubv)
            continue;
 
        if ((ubv >> 8) == 0)
        {
            --stack_top;
            open_stack[stack_top] = iso_run->item[i].ch + (signed char)(ubv & 0xff);
            /* Deal with canonical equivalent U+2329/232A and U+3008/3009. */
            if (open_stack[stack_top] == 0x232a)
                open_stack[stack_top] = 0x3009;
            stack_index[stack_top] = i;
        }
        else if ((ubv >> 8) == 1)
        {
            unsigned int j;
 
            for (j = stack_top; j < iso_run->length; ++j)
            {
                WCHAR c = iso_run->item[i].ch;
 
                if (c == 0x232a)
                    c = 0x3009;
 
                if (c != open_stack[j])
                    continue;
 
                if (!(usp10_array_reserve((void **)&out, &out_size, pair_count + 2, sizeof(*out))))
                    ERR("Failed to grow output array.\n");
 
                out[pair_count].start = stack_index[j];
                out[pair_count].end = i;
                ++pair_count;
 
                out[pair_count].start = -1;
                stack_top = j + 1;
                break;
            }
        }
    }
 
    heap_free(open_stack);
    heap_free(stack_index);
 
    if (!pair_count)
        return NULL;
 
    qsort(out, pair_count, sizeof(*out), compr);
 
    return out;
}

Referenced by resolveNeutrals().

computeIsolatingRunsSet()

static void computeIsolatingRunsSet ( unsigned  baselevel, WORD *  pcls, const WORD *  pLevel, const WCHAR *  string, unsigned int  uCount, struct list *  set  )

static

Definition at line 949 of file bidi.c.

{
    int run_start, run_end, i;
    int run_count = 0;
    Run *runs;
    IsolatedRun *current_isolated;
 
    if (!(runs = heap_calloc(uCount, sizeof(*runs))))
        return;
 
    list_init(set);
 
    /* Build Runs */
    run_start = 0;
    while (run_start < uCount)
    {
        run_end = nextValidChar(pcls, run_start, uCount);
        while (run_end < uCount && pLevel[run_end] == pLevel[run_start]) run_end = nextValidChar(pcls, run_end, uCount);
        run_end --;
        runs[run_count].start = run_start;
        runs[run_count].end = run_end;
        runs[run_count].e = pLevel[run_start];
        run_start = nextValidChar(pcls, run_end, uCount);
        run_count++;
    }
 
    /* Build Isolating Runs */
    i = 0;
    while (i < run_count)
    {
        int k = i;
        if (runs[k].start >= 0)
        {
            int type_fence, real_end;
            int j;
 
            if (!(current_isolated = heap_alloc(FIELD_OFFSET(IsolatedRun, item[uCount]))))
                break;
 
            run_start = runs[k].start;
            current_isolated->e = runs[k].e;
            current_isolated->length = (runs[k].end - runs[k].start)+1;
 
            for (j = 0; j < current_isolated->length;  j++)
            {
                current_isolated->item[j].pcls = &pcls[runs[k].start+j];
                current_isolated->item[j].ch = string[runs[k].start + j];
            }
 
            run_end = runs[k].end;
 
            TRACE("{ [%i -- %i]",run_start, run_end);
 
            if (pcls[run_end] == BN)
                run_end = previousValidChar(pcls, run_end, runs[k].start);
 
            while (run_end < uCount && (pcls[run_end] == RLI || pcls[run_end] == LRI || pcls[run_end] == FSI))
            {
                j = k+1;
search:
                while (j < run_count && pcls[runs[j].start] != PDI) j++;
                if (j < run_count && runs[i].e != runs[j].e)
                {
                    j++;
                    goto search;
                }
 
                if (j != run_count)
                {
                    int m;
                    int l = current_isolated->length;
 
                    current_isolated->length += (runs[j].end - runs[j].start)+1;
                    for (m = 0; l < current_isolated->length; l++, m++)
                    {
                        current_isolated->item[l].pcls = &pcls[runs[j].start+m];
                        current_isolated->item[l].ch = string[runs[j].start + m];
                    }
 
                    TRACE("[%i -- %i]",runs[j].start, runs[j].end);
 
                    run_end = runs[j].end;
                    if (pcls[run_end] == BN)
                        run_end = previousValidChar(pcls, run_end, runs[i].start);
                    runs[j].start = -1;
                    k = j;
                }
                else
                {
                    run_end = uCount;
                    break;
                }
            }
 
            type_fence = previousValidChar(pcls, run_start, -1);
 
            if (type_fence == -1)
                current_isolated->sos = (baselevel > pLevel[run_start])?baselevel:pLevel[run_start];
            else
                current_isolated->sos = (pLevel[type_fence] > pLevel[run_start])?pLevel[type_fence]:pLevel[run_start];
 
            current_isolated->sos = EmbeddingDirection(current_isolated->sos);
 
            if (run_end == uCount)
                current_isolated->eos = current_isolated->sos;
            else
            {
                /* eos could be an BN */
                if ( pcls[run_end] == BN )
                {
                    real_end = previousValidChar(pcls, run_end, run_start-1);
                    if (real_end < run_start)
                        real_end = run_start;
                }
                else
                    real_end = run_end;
 
                type_fence = nextValidChar(pcls, run_end, uCount);
                if (type_fence == uCount)
                    current_isolated->eos = (baselevel > pLevel[real_end])?baselevel:pLevel[real_end];
                else
                    current_isolated->eos = (pLevel[type_fence] > pLevel[real_end])?pLevel[type_fence]:pLevel[real_end];
 
                current_isolated->eos = EmbeddingDirection(current_isolated->eos);
            }
 
            list_add_tail(set, &current_isolated->entry);
            TRACE(" } level %i {%s <--> %s}\n",current_isolated->e, debug_type[current_isolated->sos], debug_type[current_isolated->eos]);
        }
        i++;
    }
 
    heap_free(runs);
}

Referenced by BIDI_DetermineLevels().

dump_types()

static void dump_types ( const char *  header, WORD *  types, int  start, int  end  )

inlinestatic

Definition at line 146 of file bidi.c.

{
    int i, len = 0;
    TRACE("%s:",header);
    for (i = start; i < end && len < 200; i++)
    {
        TRACE(" %s",debug_type[types[i]]);
        len += strlen(debug_type[types[i]])+1;
    }
    if (i != end)
        TRACE("...");
    TRACE("\n");
}

Referenced by BIDI_DetermineLevels().

EmbeddingDirection()

static WORD EmbeddingDirection ( int  level )

static

Definition at line 187 of file bidi.c.

{
    return odd(level) ? R : L;
}

Referenced by computeIsolatingRunsSet(), and resolveNeutrals().

GreaterEven()

static WORD GreaterEven ( int  i )

static

Definition at line 177 of file bidi.c.

{
    return odd(i) ? i + 1 : i + 2;
}

Referenced by resolveExplicit().

GreaterOdd()

static WORD GreaterOdd ( int  i )

static

Definition at line 182 of file bidi.c.

{
    return odd(i) ? i + 2 : i + 1;
}

Referenced by resolveExplicit().

iso_dump_types()

static void iso_dump_types ( const char *  header, IsolatedRun *  iso_run  )

inlinestatic

Definition at line 475 of file bidi.c.

{
    int i, len = 0;
    TRACE("%s:",header);
    TRACE("[ ");
    for (i = 0; i < iso_run->length && len < 200; i++)
    {
        TRACE(" %s",debug_type[*iso_run->item[i].pcls]);
        len += strlen(debug_type[*iso_run->item[i].pcls])+1;
    }
    if (i != iso_run->length)
        TRACE("...");
    TRACE(" ]\n");
}

Referenced by BIDI_DetermineLevels().

iso_nextValidChar()

static int iso_nextValidChar ( IsolatedRun *  iso_run, int  index  )

inlinestatic

Definition at line 457 of file bidi.c.

{
    if (index >= (iso_run->length-1)) return -1;
    index ++;
    while (index < iso_run->length && *iso_run->item[index].pcls == BN) index++;
    if (index == iso_run->length) return -1;
    return index;
}

Referenced by resolveNeutrals(), and resolveWeak().

iso_previousValidChar()

static int iso_previousValidChar ( IsolatedRun *  iso_run, int  index  )

inlinestatic

Definition at line 466 of file bidi.c.

{
 
    if (index <= 0) return -1;
    index --;
    while (index > -1 && *iso_run->item[index].pcls == BN) index--;
    return index;
}

Referenced by resolveNeutrals(), and resolveWeak().

nextValidChar()

static int nextValidChar ( const WORD *  pcls, int  index, int  front_fence  )

inlinestatic

Definition at line 425 of file bidi.c.

{
    if (index == front_fence) return index;
    index ++;
    while (index < front_fence && pcls[index] == BN) index ++;
    return index;
}

Referenced by computeIsolatingRunsSet().

previousValidChar()

static int previousValidChar ( const WORD *  pcls, int  index, int  back_fence  )

inlinestatic

Definition at line 417 of file bidi.c.

{
    if (index == -1 || index == back_fence) return index;
    index --;
    while (index > back_fence && pcls[index] == BN) index --;
    return index;
}

Referenced by computeIsolatingRunsSet().

resolveExplicit()

static void resolveExplicit ( int  level, WORD *  pclass, WORD *  poutLevel, WORD *  poutOverrides, int  count, BOOL  initialOverride  )

static

Definition at line 227 of file bidi.c.

{
    /* X1 */
    int overflow_isolate_count = 0;
    int overflow_embedding_count = 0;
    int valid_isolate_count = 0;
    int i;
 
    StackItem stack[MAX_DEPTH+2];
    int stack_top = MAX_DEPTH+1;
 
    stack[stack_top].level = level;
    stack[stack_top].override = NI;
    stack[stack_top].isolate = FALSE;
 
    if (initialOverride)
    {
        if (odd(level))
            push_stack(level, R, FALSE);
        else
            push_stack(level, L, FALSE);
    }
 
    for (i = 0; i < count; i++)
    {
        poutOverrides[i] = stack[stack_top].override;
 
        /* X2 */
        if (pclass[i] == RLE)
        {
            int least_odd = GreaterOdd(stack[stack_top].level);
            poutLevel[i] = stack[stack_top].level;
            if (valid_level(least_odd))
                push_stack(least_odd, NI, FALSE);
            else if (overflow_isolate_count == 0)
                overflow_embedding_count++;
        }
        /* X3 */
        else if (pclass[i] == LRE)
        {
            int least_even = GreaterEven(stack[stack_top].level);
            poutLevel[i] = stack[stack_top].level;
            if (valid_level(least_even))
                push_stack(least_even, NI, FALSE);
            else if (overflow_isolate_count == 0)
                overflow_embedding_count++;
        }
        /* X4 */
        else if (pclass[i] == RLO)
        {
            int least_odd = GreaterOdd(stack[stack_top].level);
            poutLevel[i] = stack[stack_top].level;
            if (valid_level(least_odd))
                push_stack(least_odd, R, FALSE);
            else if (overflow_isolate_count == 0)
                overflow_embedding_count++;
        }
        /* X5 */
        else if (pclass[i] == LRO)
        {
            int least_even = GreaterEven(stack[stack_top].level);
            poutLevel[i] = stack[stack_top].level;
            if (valid_level(least_even))
                push_stack(least_even, L, FALSE);
            else if (overflow_isolate_count == 0)
                overflow_embedding_count++;
        }
        /* X5a */
        else if (pclass[i] == RLI)
        {
            int least_odd = GreaterOdd(stack[stack_top].level);
            poutLevel[i] = stack[stack_top].level;
            if (valid_level(least_odd))
            {
                valid_isolate_count++;
                push_stack(least_odd, NI, TRUE);
            }
            else
                overflow_isolate_count++;
        }
        /* X5b */
        else if (pclass[i] == LRI)
        {
            int least_even = GreaterEven(stack[stack_top].level);
            poutLevel[i] = stack[stack_top].level;
            if (valid_level(least_even))
            {
                valid_isolate_count++;
                push_stack(least_even, NI, TRUE);
            }
            else
                overflow_isolate_count++;
        }
        /* X5c */
        else if (pclass[i] == FSI)
        {
            int j;
            int new_level = 0;
            int skipping = 0;
            poutLevel[i] = stack[stack_top].level;
            for (j = i+1; j < count; j++)
            {
                if (pclass[j] == LRI || pclass[j] == RLI || pclass[j] == FSI)
                {
                    skipping++;
                    continue;
                }
                else if (pclass[j] == PDI)
                {
                    if (skipping)
                        skipping --;
                    else
                        break;
                    continue;
                }
 
                if (skipping) continue;
 
                if (pclass[j] == L)
                {
                    new_level = 0;
                    break;
                }
                else if (pclass[j] == R || pclass[j] == AL)
                {
                    new_level = 1;
                    break;
                }
            }
            if (odd(new_level))
            {
                int least_odd = GreaterOdd(stack[stack_top].level);
                if (valid_level(least_odd))
                {
                    valid_isolate_count++;
                    push_stack(least_odd, NI, TRUE);
                }
                else
                    overflow_isolate_count++;
            }
            else
            {
                int least_even = GreaterEven(stack[stack_top].level);
                if (valid_level(least_even))
                {
                    valid_isolate_count++;
                    push_stack(least_even, NI, TRUE);
                }
                else
                    overflow_isolate_count++;
            }
        }
        /* X6 */
        else if (pclass[i] != B && pclass[i] != BN && pclass[i] != PDI && pclass[i] != PDF)
        {
            poutLevel[i] = stack[stack_top].level;
            if (stack[stack_top].override != NI)
                pclass[i] = stack[stack_top].override;
        }
        /* X6a */
        else if (pclass[i] == PDI)
        {
            if (overflow_isolate_count) overflow_isolate_count--;
            else if (!valid_isolate_count) {/* do nothing */}
            else
            {
                overflow_embedding_count = 0;
                while (!stack[stack_top].isolate) pop_stack();
                pop_stack();
                valid_isolate_count --;
            }
            poutLevel[i] = stack[stack_top].level;
        }
        /* X7 */
        else if (pclass[i] == PDF)
        {
            poutLevel[i] = stack[stack_top].level;
            if (overflow_isolate_count) {/* do nothing */}
            else if (overflow_embedding_count) overflow_embedding_count--;
            else if (!stack[stack_top].isolate && stack_top < (MAX_DEPTH+1))
                pop_stack();
        }
        /* X8: Nothing */
    }
    /* X9: Based on 5.2 Retaining Explicit Formatting Characters */
    for (i = 0; i < count ; i++)
        if (pclass[i] == RLE || pclass[i] == LRE || pclass[i] == RLO || pclass[i] == LRO || pclass[i] == PDF)
            pclass[i] = BN;
}

Referenced by BIDI_DetermineLevels().

resolveImplicit()

static void resolveImplicit ( const WORD *  pcls, WORD *  plevel, int  sos, int  eos  )

static

Definition at line 891 of file bidi.c.

{
    int i;
 
    /* I1/2 */
    for (i = sos; i <= eos; i++)
    {
        if (pcls[i] == BN)
            continue;
 
        ASSERT(pcls[i] > 0); /* "No Neutrals allowed to survive here." */
        ASSERT(pcls[i] < 5); /* "Out of range." */
 
        if (odd(plevel[i]) && (pcls[i] == L || pcls[i] == EN || pcls [i] == AN))
            plevel[i]++;
        else if (!odd(plevel[i]) && pcls[i] == R)
            plevel[i]++;
        else if (!odd(plevel[i]) && (pcls[i] == EN || pcls [i] == AN))
            plevel[i]+=2;
    }
}

Referenced by BIDI_DetermineLevels().

resolveNeutrals()

static void resolveNeutrals ( IsolatedRun *  iso_run )

static

Definition at line 734 of file bidi.c.

{
    int i;
    BracketPair *pairs = NULL;
 
    /* Translate isolates into NI */
    for (i = 0; i < iso_run->length; i++)
    {
        if (*iso_run->item[i].pcls >= LRI)
            *iso_run->item[i].pcls = NI;
 
        switch(*iso_run->item[i].pcls)
        {
            case B:
            case S:
            case WS: *iso_run->item[i].pcls = NI;
        }
 
        ASSERT(*iso_run->item[i].pcls < 5 || *iso_run->item[i].pcls == BN); /* "Only NI, L, R,  AN, EN and BN are allowed" */
    }
 
    /* N0: Skipping bracketed pairs for now */
    pairs = computeBracketPairs(iso_run);
    if (pairs)
    {
        BracketPair *p = &pairs[0];
        int i = 0;
        while (p->start >= 0)
        {
            int j;
            int e = EmbeddingDirection(iso_run->e);
            int o = EmbeddingDirection(iso_run->e+1);
            BOOL flag_o = FALSE;
            TRACE("Bracket Pair [%i - %i]\n",p->start, p->end);
 
            /* N0.b */
            for (j = p->start+1; j < p->end; j++)
            {
                if (N0_TYPE(*iso_run->item[j].pcls) == e)
                {
                    *iso_run->item[p->start].pcls = e;
                    *iso_run->item[p->end].pcls = e;
                    break;
                }
                else if (N0_TYPE(*iso_run->item[j].pcls) == o)
                    flag_o = TRUE;
            }
            /* N0.c */
            if (j == p->end && flag_o)
            {
                for (j = p->start; j >= 0; j--)
                {
                    if (N0_TYPE(*iso_run->item[j].pcls) == o)
                    {
                        *iso_run->item[p->start].pcls = o;
                        *iso_run->item[p->end].pcls = o;
                        break;
                    }
                    else if (N0_TYPE(*iso_run->item[j].pcls) == e)
                    {
                        *iso_run->item[p->start].pcls = e;
                        *iso_run->item[p->end].pcls = e;
                        break;
                    }
                }
                if ( j < 0 )
                {
                    *iso_run->item[p->start].pcls = iso_run->sos;
                    *iso_run->item[p->end].pcls = iso_run->sos;
                }
            }
 
            i++;
            p = &pairs[i];
        }
        heap_free(pairs);
    }
 
    /* N1 */
    for (i = 0; i < iso_run->length; i++)
    {
        WORD l,r;
 
        if (*iso_run->item[i].pcls == NI)
        {
            int j;
            int b = iso_previousValidChar(iso_run, i);
 
            if (b == -1)
            {
                l = iso_run->sos;
                b = 0;
            }
            else
            {
                if (*iso_run->item[b].pcls == R || *iso_run->item[b].pcls == AN || *iso_run->item[b].pcls == EN)
                    l = R;
                else if (*iso_run->item[b].pcls == L)
                    l = L;
                else /* No string type */
                    continue;
            }
            j = iso_nextValidChar(iso_run, i);
            while (j > -1 && *iso_run->item[j].pcls == NI) j = iso_nextValidChar(iso_run, j);
 
            if (j == -1)
            {
                r = iso_run->eos;
                j = iso_run->length;
            }
            else if (*iso_run->item[j].pcls == R || *iso_run->item[j].pcls == AN || *iso_run->item[j].pcls == EN)
                r = R;
            else if (*iso_run->item[j].pcls == L)
                r = L;
            else /* No string type */
                continue;
 
            if (r == l)
            {
                for (b = i; b < j && b < iso_run->length; b++)
                    *iso_run->item[b].pcls = r;
            }
        }
    }
 
    /* N2 */
    for (i = 0; i < iso_run->length; i++)
    {
        if (*iso_run->item[i].pcls == NI)
        {
            int b = i-1;
            int f = i+1;
            *iso_run->item[i].pcls = EmbeddingDirection(iso_run->e);
            if (b > -1 && *iso_run->item[b].pcls == BN)
                *iso_run->item[b].pcls = EmbeddingDirection(iso_run->e);
            if (f < iso_run->length && *iso_run->item[f].pcls == BN)
                *iso_run->item[f].pcls = EmbeddingDirection(iso_run->e);
        }
    }
}

Referenced by BIDI_DetermineLevels().

resolveResolved()

static void resolveResolved ( unsigned  baselevel, const WORD *  pcls, WORD *  plevel, int  sos, int  eos  )

static

Definition at line 913 of file bidi.c.

{
    int i;
 
    /* L1 */
    for (i = sos; i <= eos; i++)
    {
        if (pcls[i] == B || pcls[i] == S)
        {
            int j = i -1;
            while (i > sos  && j >= sos &&
                   (pcls[j] == WS || pcls[j] == FSI || pcls[j] == LRI || pcls[j] == RLI ||
                    pcls[j] == PDI || pcls[j] == LRE || pcls[j] == RLE || pcls[j] == LRO ||
                    pcls[j] == RLO || pcls[j] == PDF || pcls[j] == BN))
                plevel[j--] = baselevel;
            plevel[i] = baselevel;
        }
        else if (pcls[i] == LRE || pcls[i] == RLE || pcls[i] == LRO || pcls[i] == RLO ||
                 pcls[i] == PDF || pcls[i] == BN)
        {
            plevel[i] = i ? plevel[i - 1] : baselevel;
        }
        if (i == eos &&
            (pcls[i] == WS || pcls[i] == FSI || pcls[i] == LRI || pcls[i] == RLI ||
             pcls[i] == PDI || pcls[i] == LRE || pcls[i] == RLE || pcls[i] == LRO ||
             pcls[i] == RLO || pcls[i] == PDF || pcls[i] == BN ))
        {
            int j = i;
            while (j >= sos && (pcls[j] == WS || pcls[j] == FSI || pcls[j] == LRI || pcls[j] == RLI ||
                                pcls[j] == PDI || pcls[j] == LRE || pcls[j] == RLE || pcls[j] == LRO ||
                                pcls[j] == RLO || pcls[j] == PDF || pcls[j] == BN))
                plevel[j--] = baselevel;
        }
    }
}

Referenced by BIDI_DetermineLevels().

resolveWeak()

static void resolveWeak ( IsolatedRun *  iso_run )

static

Definition at line 506 of file bidi.c.

{
    int i;
 
    /* W1 */
    for (i=0; i < iso_run->length; i++)
    {
        if (*iso_run->item[i].pcls == NSM)
        {
            int j = iso_previousValidChar(iso_run, i);
            if (j == -1)
                *iso_run->item[i].pcls = iso_run->sos;
            else if (*iso_run->item[j].pcls >= LRI)
                *iso_run->item[i].pcls = ON;
            else
                *iso_run->item[i].pcls = *iso_run->item[j].pcls;
        }
    }
 
    /* W2 */
    for (i = 0; i < iso_run->length; i++)
    {
        if (*iso_run->item[i].pcls == EN)
        {
            int j = iso_previousValidChar(iso_run, i);
            while (j > -1)
            {
                if (*iso_run->item[j].pcls == R || *iso_run->item[j].pcls == L || *iso_run->item[j].pcls == AL)
                {
                    if (*iso_run->item[j].pcls == AL)
                        *iso_run->item[i].pcls = AN;
                    break;
                }
                j = iso_previousValidChar(iso_run, j);
            }
        }
    }
 
    /* W3 */
    for (i = 0; i < iso_run->length; i++)
    {
        if (*iso_run->item[i].pcls == AL)
            *iso_run->item[i].pcls = R;
    }
 
    /* W4 */
    for (i = 0; i < iso_run->length; i++)
    {
        if (*iso_run->item[i].pcls == ES)
        {
            int b = iso_previousValidChar(iso_run, i);
            int f = iso_nextValidChar(iso_run, i);
 
            if (b > -1 && f > -1 && *iso_run->item[b].pcls == EN && *iso_run->item[f].pcls == EN)
                *iso_run->item[i].pcls = EN;
        }
        else if (*iso_run->item[i].pcls == CS)
        {
            int b = iso_previousValidChar(iso_run, i);
            int f = iso_nextValidChar(iso_run, i);
 
            if (b > -1 && f > -1 && *iso_run->item[b].pcls == EN && *iso_run->item[f].pcls == EN)
                *iso_run->item[i].pcls = EN;
            else if (b > -1 && f > -1 && *iso_run->item[b].pcls == AN && *iso_run->item[f].pcls == AN)
                *iso_run->item[i].pcls = AN;
        }
    }
 
    /* W5 */
    for (i = 0; i < iso_run->length; i++)
    {
        if (*iso_run->item[i].pcls == ET)
        {
            int j;
            for (j = i-1 ; j > -1; j--)
            {
                if (*iso_run->item[j].pcls == BN) continue;
                if (*iso_run->item[j].pcls == ET) continue;
                else if (*iso_run->item[j].pcls == EN) *iso_run->item[i].pcls = EN;
                else break;
            }
            if (*iso_run->item[i].pcls == ET)
            {
                for (j = i+1; j < iso_run->length; j++)
                {
                    if (*iso_run->item[j].pcls == BN) continue;
                    if (*iso_run->item[j].pcls == ET) continue;
                    else if (*iso_run->item[j].pcls == EN) *iso_run->item[i].pcls = EN;
                    else break;
                }
            }
        }
    }
 
    /* W6 */
    for (i = 0; i < iso_run->length; i++)
    {
        if (*iso_run->item[i].pcls == ET || *iso_run->item[i].pcls == ES || *iso_run->item[i].pcls == CS || *iso_run->item[i].pcls == ON)
        {
            int b = i-1;
            int f = i+1;
            if (b > -1 && *iso_run->item[b].pcls == BN)
                *iso_run->item[b].pcls = ON;
            if (f < iso_run->length && *iso_run->item[f].pcls == BN)
                *iso_run->item[f].pcls = ON;
 
            *iso_run->item[i].pcls = ON;
        }
    }
 
    /* W7 */
    for (i = 0; i < iso_run->length; i++)
    {
        if (*iso_run->item[i].pcls == EN)
        {
            int j;
            for (j = iso_previousValidChar(iso_run, i); j > -1; j = iso_previousValidChar(iso_run, j))
                if (*iso_run->item[j].pcls == R || *iso_run->item[j].pcls == L)
                {
                    if (*iso_run->item[j].pcls == L)
                        *iso_run->item[i].pcls = L;
                    break;
                }
            if (iso_run->sos == L &&  j == -1)
                *iso_run->item[i].pcls = L;
        }
    }
}

Referenced by BIDI_DetermineLevels().

reverse()

static void reverse ( int *  pidx, int  cch  )

static

Definition at line 1153 of file bidi.c.

{
    int temp;
    int ich = 0;
    for (; ich < --cch; ich++)
    {
        temp = pidx[ich];
        pidx[ich] = pidx[cch];
        pidx[cch] = temp;
    }
}

Referenced by __next_permutation(), __prev_permutation(), BIDI_ReorderL2vLevel(), BIDI_ReorderV2lLevel(), cert_name_to_str_with_indent(), CertNameToStrA(), ft_stroke_border_close(), RmCpTest::reverse1(), and test_WinHttpAddHeaders().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

bidi

)

Variable Documentation

debug_type

const char debug_type[][4]

static

Initial value:

=
{
    "ON",      
    "L",       
    "R",       
    "AN",      
    "EN",      
    "AL",      
    "NSM",     
    "CS",      
    "ES",      
    "ET",      
    "BN",      
    "S",       
    "WS",      
    "B",       
    "RLO",     
    "RLE",
    "LRO",
    "LRE",
    "PDF",
    "LRI",     
    "RLI",
    "FSI",
    "PDI",
}

Definition at line 117 of file bidi.c.

Referenced by computeIsolatingRunsSet(), dump_types(), and iso_dump_types().

DECLSPEC_HIDDEN

const unsigned short bidi_direction_table [] DECLSPEC_HIDDEN

extern

Definition at line 58 of file bidi.c.