[jimtabor] 62535: [Usp10] - Sync to Wine 1.7.14.

Author: jimtabor
Date: Thu Mar 20 02:07:55 2014
New Revision: 62535

URL: http://svn.reactos.org/svn/reactos?rev=62535&view=rev
Log:
[Usp10] - Sync to Wine 1.7.14.

Modified:
    trunk/reactos/dll/win32/usp10/bidi.c
    trunk/reactos/dll/win32/usp10/indicsyllable.c
    trunk/reactos/dll/win32/usp10/linebreak.c
    trunk/reactos/dll/win32/usp10/shaping.c
    trunk/reactos/dll/win32/usp10/usp10.c
    trunk/reactos/media/doc/README.WINE

Modified: trunk/reactos/dll/win32/usp10/bidi.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/usp10/bidi.c?rev…
==============================================================================
--- trunk/reactos/dll/win32/usp10/bidi.c	[iso-8859-1] (original)
+++ trunk/reactos/dll/win32/usp10/bidi.c	[iso-8859-1] Thu Mar 20 02:07:55 2014
@@ -41,12 +41,16 @@
  * has been modified.
  */
 
+#include <windef.h>
+
+#include <wine/list.h>
+
 #include "usp10_internal.h"
 
 WINE_DEFAULT_DEBUG_CHANNEL(bidi);
 
 #define ASSERT(x) do { if (!(x)) FIXME("assert failed: %s\n", #x); } while(0)
-#define MAX_LEVEL 61
+#define MAX_DEPTH 125
 
 /* HELPER FUNCTIONS AND DECLARATIONS */
 
@@ -64,7 +68,7 @@
 enum directions
 {
     /* input types */
-             /* ON MUST be zero, code relies on ON = N = 0 */
+             /* ON MUST be zero, code relies on ON = NI = 0 */
     ON = 0,  /* Other Neutral */
     L,       /* Left Letter */
     R,       /* Right Letter */
@@ -91,11 +95,52 @@
     LRE,
     PDF,
 
+    LRI, /* Isolate formatting characters new with 6.3 */
+    RLI,
+    FSI,
+    PDI,
+
     /* resolved types, also resolved directions */
-    N = ON,  /* alias, where ON, WS and S are treated the same */
+    NI = ON,  /* alias, where ON, WS, S  and Isolates are treated the same */
 };
 
+static const char debug_type[][4] =
+{
+    "ON",      /* 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 %) */
+    "BN",      /* Boundary neutral (type of RLE etc after explicit levels) */
+    "S",       /* Segment Separator (TAB)        // used only in L1 */
+    "WS",      /* White space                    // used only in L1 */
+    "B",       /* Paragraph Separator (aka as PS) */
+    "RLO",     /* these are used only in X1-X9 */
+    "RLE",
+    "LRO",
+    "LRE",
+    "PDF",
+    "LRI",     /* Isolate formatting characters new with 6.3 */
+    "RLI",
+    "FSI",
+    "PDI",
+};
+
 /* HELPER FUNCTIONS */
+
+static inline void dump_types(const char* header, WORD *types, int start, int end)
+{
+    int i;
+    TRACE("%s:",header);
+    for (i = start; i< end; i++)
+        TRACE(" %s",debug_type[types[i]]);
+    TRACE("\n");
+}
 
 /* Convert the libwine information to the direction enum */
 static void classify(LPCWSTR lpString, WORD *chartype, DWORD uCount, const SCRIPT_CONTROL
*c)
@@ -132,7 +177,7 @@
             switch (lpString[i])
             {
             case '-':
-            case '+': chartype[i] = N; break;
+            case '+': chartype[i] = NI; break;
             case '/': chartype[i] = CS; break;
             }
             break;
@@ -144,20 +189,13 @@
             case 0x202C: chartype[i] = PDF; break;
             case 0x202D: chartype[i] = LRO; break;
             case 0x202E: chartype[i] = RLO; break;
+            case 0x2066: chartype[i] = LRI; break;
+            case 0x2067: chartype[i] = RLI; break;
+            case 0x2068: chartype[i] = FSI; break;
+            case 0x2069: chartype[i] = PDI; break;
             }
             break;
         }
-    }
-}
-
-/* Set a run of cval values at locations all prior to, but not including */
-/* iStart, to the new value nval. */
-static void SetDeferredRun(WORD *pval, int cval, int iStart, int nval)
-{
-    int i = iStart - 1;
-    for (; i >= iStart - cval; i--)
-    {
-        pval[i] = nval;
     }
 }
 
@@ -197,233 +235,269 @@
           the outermost call. The nesting counter counts the recursion
           depth and not the embedding level.
 ------------------------------------------------------------------------*/
-
-static int resolveExplicit(int level, int dir, WORD *pcls, WORD *plevel, int cch, int
nNest)
-{
-    /* always called with a valid nesting level
-       nesting levels are != embedding levels */
-    int nLastValid = nNest;
-    int ich = 0;
-
-    /* check input values */
-    ASSERT(nNest >= 0 && level >= 0 && level <= MAX_LEVEL);
-
-    /* process the text */
-    for (; ich < cch; ich++)
-    {
-        WORD cls = pcls[ich];
-        switch (cls)
-        {
-        case LRO:
-        case LRE:
-            nNest++;
-            if (GreaterEven(level) <= MAX_LEVEL - (cls == LRO ? 2 : 0))
-            {
-                plevel[ich] = GreaterEven(level);
-                pcls[ich] = BN;
-                ich += resolveExplicit(plevel[ich], (cls == LRE ? N : L),
-                            &pcls[ich+1], &plevel[ich+1],
-                             cch - (ich+1), nNest);
-                nNest--;
-                continue;
-            }
-            cls = pcls[ich] = BN;
-            break;
-
-        case RLO:
-        case RLE:
-            nNest++;
-            if (GreaterOdd(level) <= MAX_LEVEL - (cls == RLO ? 2 : 0))
-            {
-                plevel[ich] = GreaterOdd(level);
-                pcls[ich] = BN;
-                ich += resolveExplicit(plevel[ich], (cls == RLE ? N : R),
-                                &pcls[ich+1], &plevel[ich+1],
-                                 cch - (ich+1), nNest);
-                nNest--;
-                continue;
-            }
-            cls = pcls[ich] = BN;
-            break;
-
-        case PDF:
-            cls = pcls[ich] = BN;
-            if (nNest)
-            {
-                if (nLastValid < nNest)
-                {
-                    nNest--;
+typedef struct tagStackItem {
+    int level;
+    int override;
+    BOOL isolate;
+} StackItem;
+
+#define push_stack(l,o,i)  \
+  do { stack_top--; \
+  stack[stack_top].level = l; \
+  stack[stack_top].override = o; \
+  stack[stack_top].isolate = i;} while(0)
+
+#define pop_stack() do { stack_top++; } while(0)
+
+#define valid_level(x) (x <= MAX_DEPTH && overflow_isolate_count == 0
&& overflow_embedding_count == 0)
+
+static void resolveExplicit(int level, WORD *pclass, WORD *poutLevel, int count)
+{
+    /* 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;
+
+    for (i = 0; i < count; i++)
+    {
+        /* 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
-                {
-                    cch = ich; /* break the loop, but complete body */
-                }
-            }
-        }
-
-        /* Apply the override */
-        if (dir != N)
-        {
-            cls = dir;
-        }
-        plevel[ich] = level;
-        if (pcls[ich] != BN)
-            pcls[ich] = cls;
-    }
-
-    return ich;
-}
-
-/* RESOLVE WEAK TYPES */
-
-enum states /* possible states */
-{
-    xa,        /*  Arabic letter */
-    xr,        /*  right letter */
-    xl,        /*  left letter */
-
-    ao,        /*  Arabic lett. foll by ON */
-    ro,        /*  right lett. foll by ON */
-    lo,        /*  left lett. foll by ON */
-
-    rt,        /*  ET following R */
-    lt,        /*  ET following L */
-
-    cn,        /*  EN, AN following AL */
-    ra,        /*  Arabic number foll R */
-    re,        /*  European number foll R */
-    la,        /*  Arabic number foll L */
-    le,        /*  European number foll L */
-
-    ac,        /*  CS following cn */
-    rc,        /*  CS following ra */
-    rs,        /*  CS,ES following re */
-    lc,        /*  CS following la */
-    ls,        /*  CS,ES following le */
-
-    ret,    /*  ET following re */
-    let,    /*  ET following le */
-} ;
-
-static const int stateWeak[][10] =
-{
-    /*    N,  L,  R, AN, EN, AL,NSM, CS, ES, ET */
-/*xa*/ { ao, xl, xr, cn, cn, xa, xa, ao, ao, ao }, /* Arabic letter          */
-/*xr*/ { ro, xl, xr, ra, re, xa, xr, ro, ro, rt }, /* right letter           */
-/*xl*/ { lo, xl, xr, la, le, xa, xl, lo, lo, lt }, /* left letter            */
-
-/*ao*/ { ao, xl, xr, cn, cn, xa, ao, ao, ao, ao }, /* Arabic lett. foll by ON*/
-/*ro*/ { ro, xl, xr, ra, re, xa, ro, ro, ro, rt }, /* right lett. foll by ON */
-/*lo*/ { lo, xl, xr, la, le, xa, lo, lo, lo, lt }, /* left lett. foll by ON  */
-
-/*rt*/ { ro, xl, xr, ra, re, xa, rt, ro, ro, rt }, /* ET following R         */
-/*lt*/ { lo, xl, xr, la, le, xa, lt, lo, lo, lt }, /* ET following L         */
-
-/*cn*/ { ao, xl, xr, cn, cn, xa, cn, ac, ao, ao }, /* EN, AN following AL    */
-/*ra*/ { ro, xl, xr, ra, re, xa, ra, rc, ro, rt }, /* Arabic number foll R   */
-/*re*/ { ro, xl, xr, ra, re, xa, re, rs, rs,ret }, /* European number foll R */
-/*la*/ { lo, xl, xr, la, le, xa, la, lc, lo, lt }, /* Arabic number foll L   */
-/*le*/ { lo, xl, xr, la, le, xa, le, ls, ls,let }, /* European number foll L */
-
-/*ac*/ { ao, xl, xr, cn, cn, xa, ao, ao, ao, ao }, /* CS following cn        */
-/*rc*/ { ro, xl, xr, ra, re, xa, ro, ro, ro, rt }, /* CS following ra        */
-/*rs*/ { ro, xl, xr, ra, re, xa, ro, ro, ro, rt }, /* CS,ES following re     */
-/*lc*/ { lo, xl, xr, la, le, xa, lo, lo, lo, lt }, /* CS following la        */
-/*ls*/ { lo, xl, xr, la, le, xa, lo, lo, lo, lt }, /* CS,ES following le     */
-
-/*ret*/{ ro, xl, xr, ra, re, xa,ret, ro, ro,ret }, /* ET following re        */
-/*let*/{ lo, xl, xr, la, le, xa,let, lo, lo,let }, /* ET following le        */
-};
-
-enum actions /* possible actions */
-{
-    /* primitives */
-    IX = 0x100,                    /* increment */
-    XX = 0xF,                    /* no-op */
-
-    /* actions */
-    xxx = (XX << 4) + XX,        /* no-op */
-    xIx = IX + xxx,                /* increment run */
-    xxN = (XX << 4) + ON,        /* set current to N */
-    xxE = (XX << 4) + EN,        /* set current to EN */
-    xxA = (XX << 4) + AN,        /* set current to AN */
-    xxR = (XX << 4) + R,        /* set current to R */
-    xxL = (XX << 4) + L,        /* set current to L */
-    Nxx = (ON << 4) + 0xF,        /* set run to neutral */
-    Axx = (AN << 4) + 0xF,        /* set run to AN */
-    ExE = (EN << 4) + EN,        /* set run to EN, set current to EN */
-    NIx = (ON << 4) + 0xF + IX, /* set run to N, increment */
-    NxN = (ON << 4) + ON,        /* set run to N, set current to N */
-    NxR = (ON << 4) + R,        /* set run to N, set current to R */
-    NxE = (ON << 4) + EN,        /* set run to N, set current to EN */
-
-    AxA = (AN << 4) + AN,        /* set run to AN, set current to AN */
-    NxL = (ON << 4) + L,        /* set run to N, set current to L */
-    LxL = (L << 4) + L,            /* set run to L, set current to L */
-}  ;
-
-static const int actionWeak[][10] =
-{
-       /*  N,   L,   R,  AN,  EN,  AL, NSM,  CS,  ES,  ET */
-/*xa*/ { xxx, xxx, xxx, xxx, xxA, xxR, xxR, xxN, xxN, xxN }, /* Arabic letter          
*/
-/*xr*/ { xxx, xxx, xxx, xxx, xxE, xxR, xxR, xxN, xxN, xIx }, /* right letter           
*/
-/*xl*/ { xxx, xxx, xxx, xxx, xxL, xxR, xxL, xxN, xxN, xIx }, /* left letter            
*/
-
-/*ao*/ { xxx, xxx, xxx, xxx, xxA, xxR, xxN, xxN, xxN, xxN }, /* Arabic lett. foll by ON
*/
-/*ro*/ { xxx, xxx, xxx, xxx, xxE, xxR, xxN, xxN, xxN, xIx }, /* right lett. foll by ON 
*/
-/*lo*/ { xxx, xxx, xxx, xxx, xxL, xxR, xxN, xxN, xxN, xIx }, /* left lett. foll by ON  
*/
-
-/*rt*/ { Nxx, Nxx, Nxx, Nxx, ExE, NxR, xIx, NxN, NxN, xIx }, /* ET following R        
*/
-/*lt*/ { Nxx, Nxx, Nxx, Nxx, LxL, NxR, xIx, NxN, NxN, xIx }, /* ET following L        
*/
-
-/*cn*/ { xxx, xxx, xxx, xxx, xxA, xxR, xxA, xIx, xxN, xxN }, /* EN, AN following  AL   
*/
-/*ra*/ { xxx, xxx, xxx, xxx, xxE, xxR, xxA, xIx, xxN, xIx }, /* Arabic number foll R  
*/
-/*re*/ { xxx, xxx, xxx, xxx, xxE, xxR, xxE, xIx, xIx, xxE }, /* European number foll R
*/
-/*la*/ { xxx, xxx, xxx, xxx, xxL, xxR, xxA, xIx, xxN, xIx }, /* Arabic number foll L  
*/
-/*le*/ { xxx, xxx, xxx, xxx, xxL, xxR, xxL, xIx, xIx, xxL }, /* European number foll L
*/
-
-/*ac*/ { Nxx, Nxx, Nxx, Axx, AxA, NxR, NxN, NxN, NxN, NxN }, /* CS following cn        
*/
-/*rc*/ { Nxx, Nxx, Nxx, Axx, NxE, NxR, NxN, NxN, NxN, NIx }, /* CS following ra        
*/
-/*rs*/ { Nxx, Nxx, Nxx, Nxx, ExE, NxR, NxN, NxN, NxN, NIx }, /* CS,ES following re     
*/
-/*lc*/ { Nxx, Nxx, Nxx, Axx, NxL, NxR, NxN, NxN, NxN, NIx }, /* CS following la        
*/
-/*ls*/ { Nxx, Nxx, Nxx, Nxx, LxL, NxR, NxN, NxN, NxN, NIx }, /* CS,ES following le     
*/
-
-/*ret*/{ xxx, xxx, xxx, xxx, xxE, xxR, xxE, xxN, xxN, xxE }, /* ET following re          
 */
-/*let*/{ xxx, xxx, xxx, xxx, xxL, xxR, xxL, xxN, xxN, xxL }, /* ET following le          
 */
-};
-
-static int GetDeferredType(int action)
-{
-    return (action >> 4) & 0xF;
-}
-
-static int GetResolvedType(int action)
-{
-    return action & 0xF;
-}
-
-/* Note on action table:
-
-  States can be of two kinds:
-     - Immediate Resolution State, where each input token
-       is resolved as soon as it is seen. These states have
-       only single action codes (xxN) or the no-op (xxx)
-       for static input tokens.
-     - Deferred Resolution State, where input tokens either
-       either extend the run (xIx) or resolve its Type (e.g. Nxx).
-
-   Input classes are of three kinds
-     - Static Input Token, where the class of the token remains
-       unchanged on output (AN, L, N, R)
-     - Replaced Input Token, where the class of the token is
-       always replaced on output (AL, BN, NSM, CS, ES, ET)
-     - Conditional Input Token, where the class of the token is
-       changed on output in some, but not all, cases (EN)
-
-     Where tokens are subject to change, a double action
-     (e.g. NxA, or NxN) is _required_ after deferred states,
-     resolving both the deferred state and changing the current token.
-*/
+                    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;
+}
+
+static inline int previousValidChar(const WORD *pcls, int index, int back_fence)
+{
+    if (index == -1 || index == back_fence) return index;
+    index --;
+    while (index > back_fence && pcls[index] == BN) index --;
+    return index;
+}
+
+static inline int nextValidChar(const WORD *pcls, int index, int front_fence)
+{
+    if (index == front_fence) return index;
+    index ++;
+    while (index < front_fence && pcls[index] == BN) index ++;
+    return index;
+}
+
+typedef struct tagRun
+{
+    int start;
+    int end;
+    WORD e;
+} Run;
+
+typedef struct tagIsolatedRun
+{
+    struct list entry;
+    int length;
+    WORD sos;
+    WORD eos;
+    WORD e;
+
+    WORD *ppcls[1];
+} IsolatedRun;
+
+static inline int iso_nextValidChar(IsolatedRun *iso_run, int index)
+{
+    if (index >= (iso_run->length-1)) return -1;
+    index ++;
+    while (index < iso_run->length && *iso_run->ppcls[index] == BN)
index++;
+    if (index == iso_run->length) return -1;
+    return index;
+}
+
+static inline int iso_previousValidChar(IsolatedRun *iso_run, int index)
+{
+
+    if (index <= 0) return -1;
+    index --;
+    while (index > -1 && *iso_run->ppcls[index] == BN) index--;
+    return index;
+}
+
+static inline int iso_previousChar(IsolatedRun *iso_run, int index)
+{
+    if (index <= 0) return -1;
+    return index --;
+}
+
+static inline void iso_dump_types(const char* header, IsolatedRun *iso_run)
+{
+    int i;
+    TRACE("%s:",header);
+    TRACE("[ ");
+    for (i = 0; i < iso_run->length; i++)
+        TRACE(" %s",debug_type[*iso_run->ppcls[i]]);
+    TRACE(" ]\n");
+}
 
 /*------------------------------------------------------------------------
     Function: resolveWeak
@@ -440,178 +514,142 @@
     Note: On input only these directional classes are expected
           AL, HL, R, L,  ON, BN, NSM, AN, EN, ES, ET, CS,
 ------------------------------------------------------------------------*/
-static void resolveWeak(int baselevel, WORD *pcls, WORD *plevel, int cch)
-{
-    int state = odd(baselevel) ? xr : xl;
-    int cls;
-
-    int level = baselevel;
-    int action, clsRun, clsNew;
-    int cchRun = 0;
-    int ich = 0;
-
-    for (; ich < cch; ich++)
-    {
-        /* ignore boundary neutrals */
-        if (pcls[ich] == BN)
-        {
-            /* must flatten levels unless at a level change; */
-            plevel[ich] = level;
-
-            /* lookahead for level changes */
-            if (ich + 1 == cch && level != baselevel)
-            {
-                /* have to fixup last BN before end of the loop, since
-                 * its fix-upped value will be needed below the assert */
-                pcls[ich] = EmbeddingDirection(level);
-            }
-            else if (ich + 1 < cch && level != plevel[ich+1] &&
pcls[ich+1] != BN)
-            {
-                /* fixup LAST BN in front / after a level run to make
-                 * it act like the SOR/EOR in rule X10 */
-                int newlevel = plevel[ich+1];
-                if (level > newlevel) {
-                    newlevel = level;
-                }
-                plevel[ich] = newlevel;
-
-                /* must match assigned level */
-                pcls[ich] = EmbeddingDirection(newlevel);
-                level = plevel[ich+1];
-            }
+
+static void resolveWeak(IsolatedRun * iso_run)
+{
+    int i;
+
+    /* W1 */
+    for (i=0; i < iso_run->length; i++)
+    {
+        if (*iso_run->ppcls[i] == NSM)
+        {
+            int j = iso_previousValidChar(iso_run, i);
+            if (j == -1)
+                *iso_run->ppcls[i] = iso_run->sos;
+            else if (*iso_run->ppcls[j] >= LRI)
+                *iso_run->ppcls[i] = ON;
             else
-            {
-                /* don't interrupt runs */
-                if (cchRun)
-                {
-                    cchRun++;
-                }
-                continue;
-            }
-        }
-
-        ASSERT(pcls[ich] <= BN);
-        cls = pcls[ich];
-
-        action = actionWeak[state][cls];
-
-        /* resolve the directionality for deferred runs */
-        clsRun = GetDeferredType(action);
-        if (clsRun != XX)
-        {
-            SetDeferredRun(pcls, cchRun, ich, clsRun);
-            cchRun = 0;
-        }
-
-        /* resolve the directionality class at the current location */
-        clsNew = GetResolvedType(action);
-        if (clsNew != XX)
-            pcls[ich] = clsNew;
-
-        /* increment a deferred run */
-        if (IX & action)
-            cchRun++;
-
-        state = stateWeak[state][cls];
-    }
-
-    /* resolve any deferred runs
-     * use the direction of the current level to emulate PDF */
-    cls = EmbeddingDirection(level);
-
-    /* resolve the directionality for deferred runs */
-    clsRun = GetDeferredType(actionWeak[state][cls]);
-    if (clsRun != XX)
-        SetDeferredRun(pcls, cchRun, ich, clsRun);
-}
-
-/* RESOLVE NEUTRAL TYPES */
-
-/* action values */
-enum neutralactions
-{
-    /* action to resolve previous input */
-    nL = L,         /* resolve EN to L */
-    En = 3 << 4,    /* resolve neutrals run to embedding level direction */
-    Rn = R << 4,    /* resolve neutrals run to strong right */
-    Ln = L << 4,    /* resolved neutrals run to strong left */
-    In = (1<<8),    /* increment count of deferred neutrals */
-    LnL = (1<<4)+L, /* set run and EN to L */
-};
-
-static int GetDeferredNeutrals(int action, int level)
-{
-    action = (action >> 4) & 0xF;
-    if (action == (En >> 4))
-        return EmbeddingDirection(level);
-    else
-        return action;
-}
-
-static int GetResolvedNeutrals(int action)
-{
-    action = action & 0xF;
-    if (action == In)
-        return 0;
-    else
-        return action;
-}
-
-/* state values */
-enum resolvestates
-{
-    /* new temporary class */
-    r,  /* R and characters resolved to R */
-    l,  /* L and characters resolved to L */
-    rn, /* N preceded by right */
-    ln, /* N preceded by left */
-    a,  /* AN preceded by left (the abbreviation 'la' is used up above) */
-    na, /* N preceded by a */
-} ;
-
-
-/*------------------------------------------------------------------------
-  Notes:
-
-  By rule W7, whenever a EN is 'dominated' by an L (including start of
-  run with embedding direction = L) it is resolved to, and further treated
-  as L.
-
-  This leads to the need for 'a' and 'na' states.
-------------------------------------------------------------------------*/
-
-static const int actionNeutrals[][5] =
-{
-/*   N,  L,  R,  AN, EN = cls */
-  { In,  0,  0,  0,  0 }, /* r    right */
-  { In,  0,  0,  0,  L }, /* l    left */
-
-  { In, En, Rn, Rn, Rn }, /* rn   N preceded by right */
-  { In, Ln, En, En, LnL}, /* ln   N preceded by left */
-
-  { In,  0,  0,  0,  L }, /* a   AN preceded by left */
-  { In, En, Rn, Rn, En }, /* na   N  preceded by a */
-} ;
-
-static const int stateNeutrals[][5] =
-{
-/*   N, L,  R, AN, EN */
-  { rn, l,  r,  r,  r }, /* r   right */
-  { ln, l,  r,  a,  l }, /* l   left */
-
-  { rn, l,  r,  r,  r }, /* rn  N preceded by right */
-  { ln, l,  r,  a,  l }, /* ln  N preceded by left */
-
-  { na, l,  r,  a,  l }, /* a  AN preceded by left */
-  { na, l,  r,  a,  l }, /* na  N preceded by la */
-} ;
+                *iso_run->ppcls[i] = *iso_run->ppcls[j];
+        }
+    }
+
+    /* W2 */
+    for (i = 0; i < iso_run->length; i++)
+    {
+        if (*iso_run->ppcls[i] == EN)
+        {
+            int j = iso_previousValidChar(iso_run, i);
+            while (j > -1)
+            {
+                if (*iso_run->ppcls[j] == R || *iso_run->ppcls[j] == L ||
*iso_run->ppcls[j] == AL)
+                {
+                    if (*iso_run->ppcls[j] == AL)
+                        *iso_run->ppcls[i] = AN;
+                    break;
+                }
+                j = iso_previousValidChar(iso_run, j);
+            }
+        }
+    }
+
+    /* W3 */
+    for (i = 0; i < iso_run->length; i++)
+    {
+        if (*iso_run->ppcls[i] == AL)
+            *iso_run->ppcls[i] = R;
+    }
+
+    /* W4 */
+    for (i = 0; i < iso_run->length; i++)
+    {
+        if (*iso_run->ppcls[i] == ES)
+        {
+            int b = iso_previousValidChar(iso_run, i);
+            int f = iso_nextValidChar(iso_run, i);
+
+            if (b > -1 && f > -1 && *iso_run->ppcls[b] == EN
&& *iso_run->ppcls[f] == EN)
+                *iso_run->ppcls[i] = EN;
+        }
+        else if (*iso_run->ppcls[i] == CS)
+        {
+            int b = iso_previousValidChar(iso_run, i);
+            int f = iso_nextValidChar(iso_run, i);
+
+            if (b > -1 && f > -1 && *iso_run->ppcls[b] == EN
&& *iso_run->ppcls[f] == EN)
+                *iso_run->ppcls[i] = EN;
+            else if (b > -1 && f > -1 && *iso_run->ppcls[b] ==
AN && *iso_run->ppcls[f] == AN)
+                *iso_run->ppcls[i] = AN;
+        }
+    }
+
+    /* W5 */
+    for (i = 0; i < iso_run->length; i++)
+    {
+        if (*iso_run->ppcls[i] == ET)
+        {
+            int j;
+            for (j = i-1 ; j > -1; j--)
+            {
+                if (*iso_run->ppcls[j] == BN) continue;
+                if (*iso_run->ppcls[j] == ET) continue;
+                else if (*iso_run->ppcls[j] == EN) *iso_run->ppcls[i] = EN;
+                else break;
+            }
+            if (*iso_run->ppcls[i] == ET)
+            {
+                for (j = i+1; j < iso_run->length; j++)
+                {
+                    if (*iso_run->ppcls[j] == BN) continue;
+                    if (*iso_run->ppcls[j] == ET) continue;
+                    else if (*iso_run->ppcls[j] == EN) *iso_run->ppcls[i] = EN;
+                    else break;
+                }
+            }
+        }
+    }
+
+    /* W6 */
+    for (i = 0; i < iso_run->length; i++)
+    {
+        if (*iso_run->ppcls[i] == ET || *iso_run->ppcls[i] == ES ||
*iso_run->ppcls[i] == CS || *iso_run->ppcls[i] == ON)
+        {
+            int b = i-1;
+            int f = i+1;
+            if (b > -1 && *iso_run->ppcls[b] == BN)
+                *iso_run->ppcls[b] = ON;
+            if (f < iso_run->length && *iso_run->ppcls[f] == BN)
+                *iso_run->ppcls[f] = ON;
+
+            *iso_run->ppcls[i] = ON;
+        }
+    }
+
+    /* W7 */
+    for (i = 0; i < iso_run->length; i++)
+    {
+        if (*iso_run->ppcls[i] == EN)
+        {
+            int j;
+            for (j = iso_previousValidChar(iso_run, i); j > -1; j =
iso_previousValidChar(iso_run, j))
+                if (*iso_run->ppcls[j] == R || *iso_run->ppcls[j] == L)
+                {
+                    if (*iso_run->ppcls[j] == L)
+                        *iso_run->ppcls[i] = L;
+                    break;
+                }
+            if (iso_run->sos == L &&  j == -1)
+                *iso_run->ppcls[i] = L;
+        }
+    }
+}
 
 /*------------------------------------------------------------------------
     Function: resolveNeutrals
 
     Resolves the directionality of neutral character types.
 
-    Implements rules W7, N1 and N2 of the Unicode Bidi Algorithm.
+    Implements rules N1 and N2 of the Unicode Bidi Algorithm.
 
     Input: Array of embedding levels
            Character count
@@ -620,69 +658,94 @@
     In/Out: Array of directional classes
 
     Note: On input only these directional classes are expected
-          R,  L,  N, AN, EN and BN
+          R,  L,  NI, AN, EN and BN
 
           W8 resolves a number of ENs to L
 ------------------------------------------------------------------------*/
-static void resolveNeutrals(int baselevel, WORD *pcls, const WORD *plevel, int cch)
-{
-    /* the state at the start of text depends on the base level */
-    int state = odd(baselevel) ? r : l;
-    int cls;
-
-    int cchRun = 0;
-    int level = baselevel;
-
-    int action, clsRun, clsNew;
-    int ich = 0;
-    for (; ich < cch; ich++)
-    {
-        /* ignore boundary neutrals */
-        if (pcls[ich] == BN)
-        {
-            /* include in the count for a deferred run */
-            if (cchRun)
-                cchRun++;
-
-            /* skip any further processing */
-            continue;
-        }
-
-        ASSERT(pcls[ich] < 5); /* "Only N, L, R,  AN, EN are allowed" */
-        cls = pcls[ich];
-
-        action = actionNeutrals[state][cls];
-
-        /* resolve the directionality for deferred runs */
-        clsRun = GetDeferredNeutrals(action, level);
-        if (clsRun != N)
-        {
-            SetDeferredRun(pcls, cchRun, ich, clsRun);
-            cchRun = 0;
-        }
-
-        /* resolve the directionality class at the current location */
-        clsNew = GetResolvedNeutrals(action);
-        if (clsNew != N)
-            pcls[ich] = clsNew;
-
-        if (In & action)
-            cchRun++;
-
-        state = stateNeutrals[state][cls];
-        level = plevel[ich];
-    }
-
-    /* resolve any deferred runs */
-    cls = EmbeddingDirection(level);    /* eor has type of current level */
-
-    /* resolve the directionality for deferred runs */
-    clsRun = GetDeferredNeutrals(actionNeutrals[state][cls], level);
-    if (clsRun != N)
-        SetDeferredRun(pcls, cchRun, ich, clsRun);
-}
-
-/* RESOLVE IMPLICIT */
+static void resolveNeutrals(IsolatedRun *iso_run)
+{
+    int i;
+
+    /* Translate isolates into NI */
+    for (i = 0; i < iso_run->length; i++)
+    {
+        if (*iso_run->ppcls[i] >= LRI)
+            *iso_run->ppcls[i] = NI;
+
+        switch(*iso_run->ppcls[i])
+        {
+            case B:
+            case S:
+            case WS: *iso_run->ppcls[i] = NI;
+        }
+
+        ASSERT(*iso_run->ppcls[i] < 5 || *iso_run->ppcls[i] == BN); /*
"Only NI, L, R,  AN, EN and BN are allowed" */
+    }
+
+    /* N0: Skipping bracketed pairs for now */
+
+    /* N1 */
+    for (i = 0; i < iso_run->length; i++)
+    {
+        WORD l,r;
+
+        if (*iso_run->ppcls[i] == NI)
+        {
+            int j;
+            int b = iso_previousValidChar(iso_run, i);
+
+            if (b == -1)
+            {
+                l = iso_run->sos;
+                b = 0;
+            }
+            else
+            {
+                if (*iso_run->ppcls[b] == R || *iso_run->ppcls[b] == AN ||
*iso_run->ppcls[b] == EN)
+                    l = R;
+                else if (*iso_run->ppcls[b] == L)
+                    l = L;
+                else /* No string type */
+                    continue;
+            }
+            j = iso_nextValidChar(iso_run, i);
+            while (j > -1 && *iso_run->ppcls[j] == NI) j =
iso_nextValidChar(iso_run, j);
+
+            if (j == -1)
+            {
+                r = iso_run->eos;
+                j = iso_run->length;
+            }
+            else if (*iso_run->ppcls[j] == R || *iso_run->ppcls[j] == AN ||
*iso_run->ppcls[j] == EN)
+                r = R;
+            else if (*iso_run->ppcls[j] == L)
+                r = L;
+            else /* No string type */
+                continue;
+
+            if (r == l)
+            {
+                for (b = i; b < j && b < iso_run->length; b++)
+                    *iso_run->ppcls[b] = r;
+            }
+        }
+    }
+
+    /* N2 */
+    for (i = 0; i < iso_run->length; i++)
+    {
+        if (*iso_run->ppcls[i] == NI)
+        {
+            int b = i-1;
+            int f = i+1;
+            *iso_run->ppcls[i] = EmbeddingDirection(iso_run->e);
+            if (b > -1 && *iso_run->ppcls[b] == BN)
+                *iso_run->ppcls[b] = EmbeddingDirection(iso_run->e);
+            if (f < iso_run->length && *iso_run->ppcls[f] == BN)
+                *iso_run->ppcls[f] = EmbeddingDirection(iso_run->e);
+        }
+    }
+}
 
 /*------------------------------------------------------------------------
     Function: resolveImplicit
@@ -700,29 +763,178 @@
           Accepted subset of direction classes
           R, L, AN, EN
 ------------------------------------------------------------------------*/
-static const WORD addLevel[][4] =
-{
-          /* L,  R, AN, EN */
-/* even */ { 0,  1,  2,  2, },
-/* odd  */ { 1,  0,  1,  1, }
-
-};
-
-static void resolveImplicit(const WORD * pcls, WORD *plevel, int cch)
-{
-    int ich = 0;
-    for (; ich < cch; ich++)
-    {
-        /* cannot resolve bn here, since some bn were resolved to strong
-         * types in resolveWeak. To remove these we need the original
-         * types, which are available again in resolveWhiteSpace */
-        if (pcls[ich] == BN)
-        {
+static void resolveImplicit(const WORD * pcls, WORD *plevel, int sos, int eos)
+{
+    int i;
+
+    /* I1/2 */
+    for (i = sos; i <= eos; i++)
+    {
+        if (pcls[i] == BN)
             continue;
-        }
-        ASSERT(pcls[ich] > 0); /* "No Neutrals allowed to survive here." */
-        ASSERT(pcls[ich] < 5); /* "Out of range." */
-        plevel[ich] += addLevel[odd(plevel[ich])][pcls[ich] - 1];
+
+        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;
+    }
+}
+
+static void resolveResolved(unsigned baselevel, const WORD * pcls, WORD *plevel, int sos,
int eos)
+{
+    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;
+        }
+        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;
+        }
+    }
+}
+
+static void computeIsolatingRunsSet(unsigned baselevel, WORD *pcls, WORD *pLevel, int
uCount, struct list *set)
+{
+    int run_start, run_end, i;
+    Run runs[uCount];
+    int run_count = 0;
+    IsolatedRun *current_isolated;
+
+    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;
+            current_isolated = HeapAlloc(GetProcessHeap(), 0, sizeof(IsolatedRun) +
sizeof(WORD*)*uCount);
+
+            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->ppcls[j] = &pcls[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->ppcls[l] = &pcls[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++;
     }
 }
 
@@ -739,7 +951,9 @@
 {
     WORD *chartype;
     unsigned baselevel = 0;
-    INT j;
+    struct list IsolatingRuns;
+    IsolatedRun *iso_run, *next;
+
     TRACE("%s, %d\n", debugstr_wn(lpString, uCount), uCount);
 
     chartype = HeapAlloc(GetProcessHeap(), 0, uCount * sizeof(WORD));
@@ -752,28 +966,38 @@
     baselevel = s->uBidiLevel;
 
     classify(lpString, chartype, uCount, c);
-
-    for (j = 0; j < uCount; ++j)
-        switch(chartype[j])
-        {
-            case B:
-            case S:
-            case WS:
-            case ON: chartype[j] = N;
-            default: continue;
-        }
+    if (TRACE_ON(bidi)) dump_types("Start ", chartype, 0, uCount);
 
     /* resolve explicit */
-    resolveExplicit(baselevel, N, chartype, lpOutLevels, uCount, 0);
-
-    /* resolve weak */
-    resolveWeak(baselevel, chartype, lpOutLevels, uCount);
-
-    /* resolve neutrals */
-    resolveNeutrals(baselevel, chartype, lpOutLevels, uCount);
-
+    resolveExplicit(baselevel, chartype, lpOutLevels, uCount);
+    if (TRACE_ON(bidi)) dump_types("After Explicit", chartype, 0, uCount);
+
+    /* X10/BD13: Computer Isolating runs */
+    computeIsolatingRunsSet(baselevel, chartype, lpOutLevels, 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);
+        HeapFree(GetProcessHeap(),0,iso_run);
+    }
+
+    if (TRACE_ON(bidi)) dump_types("Before Implicit", chartype, 0, uCount);
     /* resolveImplicit */
-    resolveImplicit(chartype, lpOutLevels, uCount);
+    resolveImplicit(chartype, lpOutLevels, 0, uCount-1);
+
+    /* resolveResolvedLevels*/
+    classify(lpString, chartype, uCount, c);
+    resolveResolved(baselevel, chartype, lpOutLevels, 0, uCount-1);
 
     HeapFree(GetProcessHeap(), 0, chartype);
     return TRUE;

Modified: trunk/reactos/dll/win32/usp10/indicsyllable.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/usp10/indicsylla…
==============================================================================
--- trunk/reactos/dll/win32/usp10/indicsyllable.c	[iso-8859-1] (original)
+++ trunk/reactos/dll/win32/usp10/indicsyllable.c	[iso-8859-1] Thu Mar 20 02:07:55 2014
@@ -1,6 +1,6 @@
 /* Unicode Indic Syllabic Category */
-/* generated from http://www.unicode.org/Public/6.2.0/ucd/IndicSyllabicCategory.txt */
-/*       and from http://www.unicode.org/Public/6.2.0/ucd/IndicMatraCategory.txt */
+/* generated from http://www.unicode.org/Public/6.3.0/ucd/IndicSyllabicCategory.txt */
+/*       and from http://www.unicode.org/Public/6.3.0/ucd/IndicMatraCategory.txt */
 /* DO NOT EDIT!! */
 
 //#include "wine/unicode.h"

Modified: trunk/reactos/dll/win32/usp10/linebreak.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/usp10/linebreak.…
==============================================================================
--- trunk/reactos/dll/win32/usp10/linebreak.c	[iso-8859-1] (original)
+++ trunk/reactos/dll/win32/usp10/linebreak.c	[iso-8859-1] Thu Mar 20 02:07:55 2014
@@ -1,10 +1,10 @@
 /* Unicode Line Break Properties */
-/* generated from http://www.unicode.org/Public/6.2.0/ucd/LineBreak.txt */
+/* generated from http://www.unicode.org/Public/6.3.0/ucd/LineBreak.txt */
 /* DO NOT EDIT!! */
 
 //#include "wine/unicode.h"
 
-const unsigned short wine_linebreak_table[7056] =
+const unsigned short wine_linebreak_table[7072] =
 {
     /* level 1 offsets */
     0x0100, 0x0110, 0x0120, 0x0130, 0x0140, 0x0150, 0x0160, 0x0170,
@@ -101,87 +101,87 @@
     0x05b0, 0x10d0, 0x05b0, 0x05b0, 0x10d0, 0x10e0, 0x05b0, 0x10f0,
     0x05b0, 0x05b0, 0x05b0, 0x1100, 0x1100, 0x1110, 0x05b0, 0x1120,
     0x1130, 0x1140, 0x1150, 0x1160, 0x1170, 0x1180, 0x1190, 0x11a0,
-    0x11b0, 0x0ce0, 0x11c0, 0x11d0, 0x0870, 0x0580, 0x0580, 0x11e0,
-    0x11f0, 0x1200, 0x1210, 0x05b0, 0x05b0, 0x1220, 0x1230, 0x1240,
-    0x1250, 0x1240, 0x05b0, 0x05b0, 0x05b0, 0x1260, 0x05b0, 0x05b0,
-    0x1270, 0x1280, 0x1290, 0x12a0, 0x12b0, 0x12c0, 0x12d0, 0x05b0,
-    0x12e0, 0x12f0, 0x1300, 0x1310, 0x05b0, 0x05b0, 0x05b0, 0x05b0,
-    0x05b0, 0x1320, 0x1330, 0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x05b0,
-    0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x1340,
-    0x05b0, 0x05b0, 0x1350, 0x0870, 0x1360, 0x0870, 0x1370, 0x1370,
-    0x1370, 0x1370, 0x1370, 0x1370, 0x1370, 0x1370, 0x1370, 0x1380,
-    0x1370, 0x1370, 0x1370, 0x1370, 0x1230, 0x1370, 0x1370, 0x1390,
-    0x1370, 0x13a0, 0x13b0, 0x13c0, 0x13d0, 0x13e0, 0x13f0, 0x05b0,
-    0x1400, 0x1410, 0x05b0, 0x1420, 0x1430, 0x05b0, 0x1440, 0x1450,
-    0x05b0, 0x1460, 0x05b0, 0x1470, 0x1480, 0x1490, 0x14a0, 0x14b0,
-    0x14c0, 0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x14d0, 0x14e0, 0x14f0,
-    0x1370, 0x1500, 0x05b0, 0x05b0, 0x1510, 0x05b0, 0x1520, 0x05b0,
+    0x11b0, 0x0ce0, 0x11c0, 0x11d0, 0x11e0, 0x0580, 0x0580, 0x11f0,
+    0x1200, 0x1210, 0x1220, 0x05b0, 0x05b0, 0x1230, 0x1240, 0x1250,
+    0x1260, 0x1250, 0x05b0, 0x05b0, 0x05b0, 0x1270, 0x05b0, 0x05b0,
+    0x1280, 0x1290, 0x12a0, 0x12b0, 0x12c0, 0x12d0, 0x12e0, 0x05b0,
+    0x12f0, 0x1300, 0x1310, 0x1320, 0x05b0, 0x05b0, 0x05b0, 0x05b0,
+    0x05b0, 0x1330, 0x1340, 0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x05b0,
+    0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x1350,
+    0x05b0, 0x05b0, 0x1360, 0x0870, 0x1370, 0x0870, 0x1380, 0x1380,
+    0x1380, 0x1380, 0x1380, 0x1380, 0x1380, 0x1380, 0x1380, 0x1390,
+    0x1380, 0x1380, 0x1380, 0x1380, 0x1240, 0x1380, 0x1380, 0x13a0,
+    0x1380, 0x13b0, 0x13c0, 0x13d0, 0x13e0, 0x13f0, 0x1400, 0x05b0,
+    0x1410, 0x1420, 0x05b0, 0x1430, 0x1440, 0x05b0, 0x1450, 0x1460,
+    0x05b0, 0x1470, 0x05b0, 0x1480, 0x1490, 0x14a0, 0x14b0, 0x14c0,
+    0x14d0, 0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x14e0, 0x14f0, 0x1500,
+    0x1380, 0x1510, 0x05b0, 0x05b0, 0x1520, 0x05b0, 0x1530, 0x05b0,
     0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x05b0,
-    0x1530, 0x1540, 0x05b0, 0x05b0, 0x05b0, 0x1550, 0x05b0, 0x1560,
-    0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x0ce0, 0x1570, 0x0870, 0x0870,
+    0x1540, 0x1550, 0x05b0, 0x05b0, 0x05b0, 0x1560, 0x05b0, 0x1570,
+    0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x0ce0, 0x1580, 0x0870, 0x0870,
     0x0870, 0x0870, 0x0870, 0x0870, 0x0870, 0x0870, 0x0870, 0x0870,
     0x05b0, 0x05b0, 0x0850, 0x05b0, 0x05b0, 0x0850, 0x05b0, 0x05b0,
-    0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x1580, 0x1590,
-    0x05b0, 0x05b0, 0x0d70, 0x05b0, 0x05b0, 0x05b0, 0x15a0, 0x15b0,
-    0x05b0, 0x1350, 0x15c0, 0x15c0, 0x15c0, 0x15c0, 0x0580, 0x0580,
-    0x15d0, 0x15e0, 0x15f0, 0x1600, 0x0870, 0x0870, 0x0870, 0x0870,
-    0x1610, 0x1620, 0x1610, 0x1610, 0x1610, 0x1610, 0x1610, 0x1340,
-    0x1610, 0x1610, 0x1610, 0x1610, 0x1610, 0x1610, 0x1610, 0x1610,
-    0x1610, 0x1610, 0x1610, 0x1610, 0x1610, 0x1630, 0x0870, 0x1640,
-    0x1650, 0x1660, 0x1670, 0x1680, 0x1690, 0x1610, 0x16a0, 0x1610,
-    0x16b0, 0x16c0, 0x16d0, 0x1610, 0x16a0, 0x1610, 0x16b0, 0x16e0,
-    0x16f0, 0x1610, 0x1700, 0x1710, 0x1610, 0x1610, 0x1610, 0x1610,
-    0x1720, 0x1610, 0x1610, 0x1730, 0x1610, 0x1610, 0x1340, 0x1740,
-    0x1610, 0x1720, 0x1610, 0x1610, 0x1750, 0x1610, 0x1610, 0x1610,
-    0x1610, 0x1610, 0x1610, 0x1610, 0x1610, 0x1610, 0x1610, 0x1720,
-    0x1610, 0x1610, 0x1610, 0x1610, 0x1610, 0x1610, 0x1610, 0x1610,
-    0x1610, 0x1610, 0x1610, 0x1610, 0x1610, 0x1610, 0x1610, 0x1610,
-    0x1610, 0x1610, 0x1610, 0x1610, 0x1610, 0x1610, 0x1610, 0x1610,
-    0x1610, 0x1610, 0x1610, 0x1610, 0x05b0, 0x05b0, 0x05b0, 0x05b0,
-    0x1610, 0x1760, 0x1610, 0x1610, 0x1610, 0x1610, 0x1610, 0x1610,
-    0x1610, 0x1610, 0x1610, 0x1610, 0x1610, 0x1610, 0x1610, 0x1610,
-    0x1610, 0x1610, 0x1610, 0x1610, 0x1610, 0x1610, 0x1610, 0x1610,
-    0x1770, 0x1610, 0x1610, 0x1610, 0x1780, 0x05b0, 0x05b0, 0x1070,
-    0x1790, 0x05b0, 0x17a0, 0x0870, 0x05b0, 0x05b0, 0x1580, 0x17b0,
-    0x05b0, 0x17c0, 0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x17d0,
+    0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x1590, 0x15a0,
+    0x05b0, 0x05b0, 0x0d70, 0x05b0, 0x05b0, 0x05b0, 0x15b0, 0x15c0,
+    0x05b0, 0x1360, 0x15d0, 0x15d0, 0x15d0, 0x15d0, 0x0580, 0x0580,
+    0x15e0, 0x15f0, 0x1600, 0x1610, 0x0870, 0x0870, 0x0870, 0x0870,
+    0x1620, 0x1630, 0x1620, 0x1620, 0x1620, 0x1620, 0x1620, 0x1350,
+    0x1620, 0x1620, 0x1620, 0x1620, 0x1620, 0x1620, 0x1620, 0x1620,
+    0x1620, 0x1620, 0x1620, 0x1620, 0x1620, 0x1640, 0x0870, 0x1650,
+    0x1660, 0x1670, 0x1680, 0x1690, 0x16a0, 0x1620, 0x16b0, 0x1620,
+    0x16c0, 0x16d0, 0x16e0, 0x1620, 0x16b0, 0x1620, 0x16c0, 0x16f0,
+    0x1700, 0x1620, 0x1710, 0x1720, 0x1620, 0x1620, 0x1620, 0x1620,
+    0x1730, 0x1620, 0x1620, 0x1740, 0x1620, 0x1620, 0x1350, 0x1750,
+    0x1620, 0x1730, 0x1620, 0x1620, 0x1760, 0x1620, 0x1620, 0x1620,
+    0x1620, 0x1620, 0x1620, 0x1620, 0x1620, 0x1620, 0x1620, 0x1730,
+    0x1620, 0x1620, 0x1620, 0x1620, 0x1620, 0x1620, 0x1620, 0x1620,
+    0x1620, 0x1620, 0x1620, 0x1620, 0x1620, 0x1620, 0x1620, 0x1620,
+    0x1620, 0x1620, 0x1620, 0x1620, 0x1620, 0x1620, 0x1620, 0x1620,
+    0x1620, 0x1620, 0x1620, 0x1620, 0x05b0, 0x05b0, 0x05b0, 0x05b0,
+    0x1620, 0x1770, 0x1620, 0x1620, 0x1620, 0x1620, 0x1620, 0x1620,
+    0x1620, 0x1620, 0x1620, 0x1620, 0x1620, 0x1620, 0x1620, 0x1620,
+    0x1620, 0x1620, 0x1620, 0x1620, 0x1620, 0x1620, 0x1620, 0x1620,
+    0x1780, 0x1620, 0x1620, 0x1620, 0x1790, 0x05b0, 0x05b0, 0x1070,
+    0x17a0, 0x05b0, 0x17b0, 0x0870, 0x05b0, 0x05b0, 0x1590, 0x17c0,
+    0x05b0, 0x17d0, 0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x17e0,
     0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x05b0,
-    0x0850, 0x17e0, 0x1360, 0x0870, 0x0870, 0x0870, 0x0870, 0x0b10,
-    0x17f0, 0x05b0, 0x1800, 0x1810, 0x05b0, 0x05b0, 0x05b0, 0x1820,
-    0x1830, 0x05b0, 0x05b0, 0x0fd0, 0x1840, 0x0ee0, 0x0580, 0x1850,
-    0x07c0, 0x05b0, 0x1860, 0x05b0, 0x1870, 0x1880, 0x0d80, 0x1890,
-    0x08b0, 0x05b0, 0x05b0, 0x18a0, 0x18b0, 0x18c0, 0x0870, 0x0870,
-    0x05b0, 0x05b0, 0x18d0, 0x10b0, 0x18e0, 0x18f0, 0x0c10, 0x0f60,
-    0x0c10, 0x0c10, 0x0c10, 0x0c10, 0x1900, 0x1910, 0x0770, 0x1920,
-    0x1930, 0x1940, 0x15c0, 0x0870, 0x0870, 0x0870, 0x0870, 0x0870,
-    0x0870, 0x0870, 0x0870, 0x0870, 0x05b0, 0x05b0, 0x1950, 0x0ee0,
-    0x1960, 0x1970, 0x1980, 0x1990, 0x1980, 0x19a0, 0x1980, 0x1960,
-    0x1970, 0x1980, 0x1990, 0x1980, 0x19a0, 0x1980, 0x1960, 0x1970,
-    0x1980, 0x1990, 0x1980, 0x19a0, 0x1980, 0x1960, 0x1970, 0x1980,
-    0x1990, 0x1980, 0x19a0, 0x1980, 0x1960, 0x1970, 0x1980, 0x1990,
-    0x1980, 0x19a0, 0x1980, 0x1960, 0x1970, 0x1980, 0x1990, 0x1980,
-    0x19a0, 0x1980, 0x1960, 0x1970, 0x1980, 0x1990, 0x1980, 0x19a0,
-    0x1980, 0x1960, 0x1970, 0x1980, 0x1990, 0x1980, 0x19a0, 0x1980,
-    0x1960, 0x1970, 0x1980, 0x1990, 0x1980, 0x19a0, 0x1980, 0x1960,
-    0x1970, 0x1980, 0x1990, 0x1980, 0x19a0, 0x1980, 0x1960, 0x1970,
-    0x1980, 0x1990, 0x1980, 0x19a0, 0x1980, 0x1960, 0x1970, 0x1980,
-    0x1990, 0x1980, 0x19a0, 0x1980, 0x1960, 0x1970, 0x1980, 0x1990,
-    0x1980, 0x19a0, 0x1980, 0x1960, 0x1970, 0x1980, 0x1990, 0x1980,
-    0x19a0, 0x1980, 0x1960, 0x1970, 0x1980, 0x1990, 0x1980, 0x19a0,
-    0x1980, 0x1960, 0x1970, 0x1980, 0x1990, 0x1980, 0x19a0, 0x1980,
-    0x1980, 0x1990, 0x1980, 0x19a0, 0x1980, 0x1960, 0x1970, 0x1980,
-    0x1990, 0x1980, 0x19b0, 0x0d90, 0x19c0, 0x0db0, 0x0db0, 0x19d0,
-    0x19e0, 0x19e0, 0x19e0, 0x19e0, 0x19e0, 0x19e0, 0x19e0, 0x19e0,
-    0x19e0, 0x19e0, 0x19e0, 0x19e0, 0x19e0, 0x19e0, 0x19e0, 0x19e0,
+    0x0850, 0x17f0, 0x1370, 0x0870, 0x0870, 0x0870, 0x0870, 0x0b10,
+    0x1800, 0x05b0, 0x1810, 0x1820, 0x05b0, 0x05b0, 0x05b0, 0x1830,
+    0x1840, 0x05b0, 0x05b0, 0x0fd0, 0x1850, 0x0ee0, 0x0580, 0x1860,
+    0x07c0, 0x05b0, 0x1870, 0x05b0, 0x1880, 0x1890, 0x0d80, 0x18a0,
+    0x08b0, 0x05b0, 0x05b0, 0x18b0, 0x18c0, 0x18d0, 0x0870, 0x0870,
+    0x05b0, 0x05b0, 0x18e0, 0x10b0, 0x18f0, 0x1900, 0x0c10, 0x0f60,
+    0x0c10, 0x0c10, 0x0c10, 0x0c10, 0x1910, 0x1920, 0x0770, 0x1930,
+    0x1940, 0x1950, 0x15d0, 0x0870, 0x0870, 0x0870, 0x0870, 0x0870,
+    0x0870, 0x0870, 0x0870, 0x0870, 0x05b0, 0x05b0, 0x1960, 0x0ee0,
+    0x1970, 0x1980, 0x1990, 0x19a0, 0x1990, 0x19b0, 0x1990, 0x1970,
+    0x1980, 0x1990, 0x19a0, 0x1990, 0x19b0, 0x1990, 0x1970, 0x1980,
+    0x1990, 0x19a0, 0x1990, 0x19b0, 0x1990, 0x1970, 0x1980, 0x1990,
+    0x19a0, 0x1990, 0x19b0, 0x1990, 0x1970, 0x1980, 0x1990, 0x19a0,
+    0x1990, 0x19b0, 0x1990, 0x1970, 0x1980, 0x1990, 0x19a0, 0x1990,
+    0x19b0, 0x1990, 0x1970, 0x1980, 0x1990, 0x19a0, 0x1990, 0x19b0,
+    0x1990, 0x1970, 0x1980, 0x1990, 0x19a0, 0x1990, 0x19b0, 0x1990,
+    0x1970, 0x1980, 0x1990, 0x19a0, 0x1990, 0x19b0, 0x1990, 0x1970,
+    0x1980, 0x1990, 0x19a0, 0x1990, 0x19b0, 0x1990, 0x1970, 0x1980,
+    0x1990, 0x19a0, 0x1990, 0x19b0, 0x1990, 0x1970, 0x1980, 0x1990,
+    0x19a0, 0x1990, 0x19b0, 0x1990, 0x1970, 0x1980, 0x1990, 0x19a0,
+    0x1990, 0x19b0, 0x1990, 0x1970, 0x1980, 0x1990, 0x19a0, 0x1990,
+    0x19b0, 0x1990, 0x1970, 0x1980, 0x1990, 0x19a0, 0x1990, 0x19b0,
+    0x1990, 0x1970, 0x1980, 0x1990, 0x19a0, 0x1990, 0x19b0, 0x1990,
+    0x1990, 0x19a0, 0x1990, 0x19b0, 0x1990, 0x1970, 0x1980, 0x1990,
+    0x19a0, 0x1990, 0x19c0, 0x0d90, 0x19d0, 0x0db0, 0x0db0, 0x19e0,
+    0x19f0, 0x19f0, 0x19f0, 0x19f0, 0x19f0, 0x19f0, 0x19f0, 0x19f0,
+    0x19f0, 0x19f0, 0x19f0, 0x19f0, 0x19f0, 0x19f0, 0x19f0, 0x19f0,
     0x0870, 0x0870, 0x0870, 0x0870, 0x0870, 0x0870, 0x0870, 0x0870,
     0x0870, 0x0870, 0x0870, 0x0870, 0x0870, 0x0870, 0x0870, 0x0870,
-    0x1350, 0x19f0, 0x1a00, 0x1a10, 0x1a20, 0x05b0, 0x05b0, 0x05b0,
-    0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x1a30, 0x1a40, 0x05b0, 0x05b0,
-    0x05b0, 0x05b0, 0x05b0, 0x1a50, 0x0870, 0x05b0, 0x05b0, 0x05b0,
-    0x05b0, 0x1a60, 0x05b0, 0x05b0, 0x06b0, 0x0870, 0x0870, 0x1a70,
-    0x0580, 0x1a80, 0x10b0, 0x1a90, 0x1aa0, 0x1ab0, 0x1ac0, 0x1100,
-    0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x1ad0,
-    0x1ae0, 0x1af0, 0x1610, 0x1b00, 0x1610, 0x1b10, 0x1b20, 0x1b30,
-    0x05b0, 0x1b40, 0x05b0, 0x0850, 0x1b50, 0x1b60, 0x1b70, 0x1b80,
+    0x1360, 0x1a00, 0x1a10, 0x1a20, 0x1a30, 0x05b0, 0x05b0, 0x05b0,
+    0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x1a40, 0x1a50, 0x05b0, 0x05b0,
+    0x05b0, 0x05b0, 0x05b0, 0x1a60, 0x0870, 0x05b0, 0x05b0, 0x05b0,
+    0x05b0, 0x1a70, 0x05b0, 0x05b0, 0x06b0, 0x0870, 0x0870, 0x1a80,
+    0x0580, 0x1a90, 0x10b0, 0x1aa0, 0x1ab0, 0x1ac0, 0x1ad0, 0x1100,
+    0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x05b0, 0x1ae0,
+    0x1af0, 0x1b00, 0x1620, 0x1b10, 0x1620, 0x1b20, 0x1b30, 0x1b40,
+    0x05b0, 0x1b50, 0x05b0, 0x0850, 0x1b60, 0x1b70, 0x1b80, 0x1b90,
     /* values */
     0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004,
     0x0004, 0x0022, 0x0003, 0x0001, 0x0001, 0x0002, 0x0004, 0x0004,
@@ -246,7 +246,7 @@
     0x001d, 0x001d, 0x001d, 0x001d, 0x001d, 0x0011, 0x001d, 0x001d,
     0x001d, 0x001b, 0x001b, 0x001b, 0x0019, 0x0019, 0x001d, 0x001d,
     0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004,
-    0x0004, 0x0004, 0x0004, 0x0017, 0x0011, 0x0011, 0x0017, 0x0017,
+    0x0004, 0x0004, 0x0004, 0x0017, 0x0004, 0x0011, 0x0017, 0x0017,
     0x001d, 0x001d, 0x001d, 0x001d, 0x001d, 0x001d, 0x001d, 0x001d,
     0x001d, 0x001d, 0x001d, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004,
     0x001c, 0x001c, 0x001c, 0x001c, 0x001c, 0x001c, 0x001c, 0x001c,
@@ -571,8 +571,8 @@
     0x0016, 0x0016, 0x001d, 0x001d, 0x001d, 0x001d, 0x001d, 0x001d,
     0x001d, 0x001d, 0x001d, 0x001d, 0x001d, 0x001d, 0x0022, 0x001d,
     0x0022, 0x0022, 0x0022, 0x0022, 0x001d, 0x0022, 0x0022, 0x0022,
-    0x000b, 0x001d, 0x001d, 0x001d, 0x001d, 0x0011, 0x0011, 0x0011,
-    0x0011, 0x0011, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004,
+    0x000b, 0x001d, 0x001d, 0x001d, 0x001d, 0x0011, 0x0004, 0x0004,
+    0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004,
     0x001d, 0x001d, 0x0011, 0x0011, 0x0024, 0x001d, 0x001d, 0x001d,
     0x001d, 0x001d, 0x001d, 0x001d, 0x001d, 0x0012, 0x0013, 0x0024,
     0x001d, 0x0024, 0x0024, 0x0024, 0x0024, 0x001d, 0x001d, 0x001d,
@@ -580,7 +580,9 @@
     0x001a, 0x001a, 0x001a, 0x001a, 0x001a, 0x001a, 0x001a, 0x001b,
     0x001a, 0x001a, 0x001a, 0x001a, 0x001a, 0x001a, 0x001a, 0x001a,
     0x001a, 0x001a, 0x001a, 0x001a, 0x001a, 0x001a, 0x001b, 0x001a,
-    0x001a, 0x001a, 0x001a, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,
+    0x001a, 0x001a, 0x001a, 0x001a, 0x001a, 0x001a, 0x001a, 0x001a,
+    0x001a, 0x001a, 0x001a, 0x001a, 0x001a, 0x001a, 0x001a, 0x001a,
+    0x001a, 0x001a, 0x001a, 0x001a, 0x001a, 0x001a, 0x001a, 0x001a,
     0x0004, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,
     0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,
     0x001d, 0x001d, 0x001d, 0x001b, 0x001d, 0x0024, 0x001d, 0x001d,
@@ -723,13 +725,13 @@
     0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,
     0x001e, 0x001e, 0x001e, 0x001e, 0x001e, 0x001e, 0x001e, 0x001e,
     0x001e, 0x001e, 0x001e, 0x001e, 0x0011, 0x0011, 0x0011, 0x0011,
-    0x001e, 0x0013, 0x0013, 0x001e, 0x001e, 0x0016, 0x001e, 0x001e,
+    0x0022, 0x0013, 0x0013, 0x001e, 0x001e, 0x0016, 0x001e, 0x001e,
     0x0012, 0x0013, 0x0012, 0x0013, 0x0012, 0x0013, 0x0012, 0x0013,
     0x0012, 0x0013, 0x001e, 0x001e, 0x0012, 0x0013, 0x0012, 0x0013,
     0x0012, 0x0013, 0x0012, 0x0013, 0x0016, 0x0012, 0x0013, 0x0013,
     0x001e, 0x001e, 0x001e, 0x001e, 0x001e, 0x001e, 0x001e, 0x001e,
     0x001e, 0x001e, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004,
-    0x001e, 0x001e, 0x001e, 0x001e, 0x001e, 0x001e, 0x001e, 0x001e,
+    0x001e, 0x001e, 0x001e, 0x001e, 0x001e, 0x0004, 0x001e, 0x001e,
     0x001e, 0x001e, 0x001e, 0x0016, 0x0016, 0x001e, 0x001e, 0x001e,
     0x0011, 0x0027, 0x001e, 0x0027, 0x001e, 0x0027, 0x001e, 0x0027,
     0x001e, 0x0027, 0x001e, 0x001e, 0x001e, 0x001e, 0x001e, 0x001e,

Modified: trunk/reactos/dll/win32/usp10/shaping.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/usp10/shaping.c?…
==============================================================================
--- trunk/reactos/dll/win32/usp10/shaping.c	[iso-8859-1] (original)
+++ trunk/reactos/dll/win32/usp10/shaping.c	[iso-8859-1] Thu Mar 20 02:07:55 2014
@@ -1,10 +1,10 @@
 /* Unicode Arabic shaping */
-/* generated from http://www.unicode.org/Public/6.2.0/ucd/ArabicShaping.txt */
+/* generated from http://www.unicode.org/Public/6.3.0/ucd/ArabicShaping.txt */
 /* DO NOT EDIT!! */
 
 //#include "wine/unicode.h"
 
-const unsigned short wine_shaping_table[2752] =
+const unsigned short wine_shaping_table[2800] =
 {
     /* level 1 offsets */
     0x0100, 0x0110, 0x0110, 0x0120, 0x0130, 0x0140, 0x0150, 0x0160,
@@ -76,42 +76,42 @@
     0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340,
     0x0340, 0x0820, 0x0340, 0x0820, 0x0340, 0x0610, 0x0340, 0x0610,
     0x0340, 0x0340, 0x0340, 0x0830, 0x0840, 0x0850, 0x0340, 0x0340,
-    0x0860, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340,
-    0x0340, 0x0340, 0x0870, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340,
-    0x0340, 0x0340, 0x0880, 0x0890, 0x0340, 0x0340, 0x0340, 0x0340,
-    0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340,
-    0x0340, 0x08a0, 0x0340, 0x0340, 0x0340, 0x08b0, 0x08c0, 0x08d0,
-    0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340,
-    0x08e0, 0x0340, 0x0340, 0x08f0, 0x06b0, 0x0340, 0x0900, 0x08e0,
-    0x0910, 0x0340, 0x0920, 0x0340, 0x0340, 0x0340, 0x0930, 0x0910,
-    0x0340, 0x0340, 0x0940, 0x0950, 0x0340, 0x0340, 0x0340, 0x0340,
-    0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0960, 0x0970, 0x0980,
-    0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340,
-    0x0340, 0x0340, 0x0340, 0x0340, 0x0360, 0x0360, 0x0990, 0x0940,
-    0x09a0, 0x0340, 0x09b0, 0x0340, 0x0340, 0x0340, 0x09c0, 0x0340,
+    0x0860, 0x0340, 0x0530, 0x0530, 0x0530, 0x0530, 0x0530, 0x0870,
+    0x0880, 0x0530, 0x0890, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340,
+    0x0340, 0x0340, 0x08a0, 0x08b0, 0x0340, 0x0340, 0x0340, 0x0340,
+    0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340,
+    0x0340, 0x08c0, 0x0340, 0x0340, 0x0340, 0x08d0, 0x08e0, 0x08f0,
+    0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340,
+    0x0900, 0x0340, 0x0340, 0x0910, 0x06b0, 0x0340, 0x0920, 0x0900,
+    0x0930, 0x0340, 0x0940, 0x0340, 0x0340, 0x0340, 0x0950, 0x0930,
+    0x0340, 0x0340, 0x0960, 0x0970, 0x0340, 0x0340, 0x0340, 0x0340,
+    0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0980, 0x0990, 0x09a0,
+    0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340,
+    0x0340, 0x0340, 0x0340, 0x0340, 0x0360, 0x0360, 0x09b0, 0x0960,
+    0x09c0, 0x0340, 0x09d0, 0x0340, 0x0340, 0x0340, 0x09e0, 0x0340,
     0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0360, 0x0360, 0x0510,
     0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340,
-    0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0490, 0x0910,
+    0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0490, 0x0930,
     0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0490,
     0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0360, 0x0360,
-    0x0340, 0x0340, 0x09d0, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340,
-    0x0340, 0x09e0, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340,
-    0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0490, 0x09f0,
-    0x0340, 0x0490, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0910,
-    0x0a00, 0x0340, 0x06f0, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340,
-    0x0340, 0x0340, 0x0340, 0x0340, 0x0980, 0x0340, 0x0360, 0x0910,
-    0x0340, 0x0340, 0x0a10, 0x0340, 0x0a20, 0x0910, 0x0340, 0x0340,
-    0x05d0, 0x0340, 0x0340, 0x0a30, 0x0340, 0x0340, 0x0340, 0x0340,
-    0x0340, 0x0340, 0x0a40, 0x0a50, 0x0a60, 0x0340, 0x0340, 0x0340,
-    0x0340, 0x0340, 0x0340, 0x0a70, 0x0620, 0x0340, 0x0a80, 0x06a0,
-    0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340,
-    0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0a90, 0x0340,
-    0x0340, 0x0aa0, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340,
-    0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340,
-    0x0360, 0x0340, 0x0990, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340,
+    0x0340, 0x0340, 0x09f0, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340,
+    0x0340, 0x0a00, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340,
+    0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0490, 0x0a10,
+    0x0340, 0x0490, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0930,
+    0x0a20, 0x0340, 0x06f0, 0x0340, 0x0530, 0x0530, 0x0530, 0x0a30,
+    0x0340, 0x0340, 0x0340, 0x0340, 0x09a0, 0x0340, 0x0360, 0x0930,
+    0x0340, 0x0340, 0x0a40, 0x0340, 0x0a50, 0x0930, 0x0340, 0x0340,
+    0x05d0, 0x0340, 0x0340, 0x0a60, 0x0340, 0x0340, 0x0340, 0x0340,
+    0x0340, 0x0340, 0x0a70, 0x0a80, 0x0a90, 0x0340, 0x0340, 0x0340,
+    0x0340, 0x0340, 0x0340, 0x0aa0, 0x0620, 0x0340, 0x0ab0, 0x06a0,
+    0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340,
+    0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0ac0, 0x0340,
+    0x0340, 0x0ad0, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340,
+    0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340,
+    0x0360, 0x0340, 0x09b0, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340,
     0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0490,
     0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340,
-    0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0ab0,
+    0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0340, 0x0ae0,
     /* values */
     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
@@ -128,7 +128,7 @@
     0x0000, 0x0001, 0x0001, 0x0000, 0x0001, 0x0001, 0x0000, 0x0001,
     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
     0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
-    0x0001, 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+    0x0001, 0x0001, 0x0001, 0x0000, 0x0001, 0x0000, 0x0000, 0x0000,
     0x0104, 0x0000, 0x0202, 0x0202, 0x0302, 0x0202, 0x0104, 0x0202,
     0x0404, 0x0502, 0x0404, 0x0404, 0x0604, 0x0604, 0x0604, 0x0702,
     0x0702, 0x0802, 0x0802, 0x0904, 0x0904, 0x0a04, 0x0a04, 0x0b04,
@@ -277,16 +277,20 @@
     0x0000, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
     0x0001, 0x0001, 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000,
     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000, 0x0000,
-    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
-    0x0000, 0x0000, 0x0000, 0x0001, 0x0001, 0x0001, 0x0000, 0x0000,
-    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
-    0x0000, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0004,
+    0x0000, 0x0000, 0x0005, 0x0001, 0x0001, 0x0001, 0x0000, 0x0000,
+    0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004,
+    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0004,
+    0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004,
+    0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004,
+    0x0004, 0x0001, 0x0004, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
     0x0001, 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001,
     0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
     0x0000, 0x0000, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
     0x0000, 0x0001, 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000,
     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001,
-    0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+    0x0001, 0x0000, 0x0000, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000,
     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000,
     0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0000,
     0x0001, 0x0000, 0x0001, 0x0000, 0x0000, 0x0001, 0x0001, 0x0001,
@@ -331,6 +335,8 @@
     0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0000, 0x0000,
     0x0000, 0x0000, 0x0001, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000,
     0x0000, 0x0000, 0x0000, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000,
+    0x0004, 0x0004, 0x0003, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0001,
     0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0000, 0x0000,
     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001,

Modified: trunk/reactos/dll/win32/usp10/usp10.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/usp10/usp10.c?re…
==============================================================================
--- trunk/reactos/dll/win32/usp10/usp10.c	[iso-8859-1] (original)
+++ trunk/reactos/dll/win32/usp10/usp10.c	[iso-8859-1] Thu Mar 20 02:07:55 2014
@@ -1381,7 +1381,7 @@
         else
         {
             BOOL inNumber = FALSE;
-            static WCHAR math_punc[] =
{'#','$','%','+',',','-','.','/',':',0x2212,
0x2044, 0x00a0,0};
+            static const WCHAR math_punc[] =
{'#','$','%','+',',','-','.','/',':',0x2212,
0x2044, 0x00a0,0};
 
             strength = heap_alloc_zero(cInChars * sizeof(WORD));
             if (!strength)

Modified: trunk/reactos/media/doc/README.WINE
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/media/doc/README.WINE?rev=…
==============================================================================
--- trunk/reactos/media/doc/README.WINE	[iso-8859-1] (original)
+++ trunk/reactos/media/doc/README.WINE	[iso-8859-1] Thu Mar 20 02:07:55 2014
@@ -195,7 +195,7 @@
 reactos/dll/win32/updspapi         # Synced to Wine-1.7.1
 reactos/dll/win32/url              # Synced to Wine-1.7.1
 reactos/dll/win32/urlmon           # Synced to Wine-1.7.1
-reactos/dll/win32/usp10            # Synced to Wine-1.7.1
+reactos/dll/win32/usp10            # Synced to Wine-1.7.14
 reactos/dll/win32/uxtheme          # Forked
 reactos/dll/win32/vbscript         # Synced to Wine-1.7.1
 reactos/dll/win32/version          # Synced to Wine-1.7.1