Update ICU to 54.1 step 1

source/common/ubidiimp.h

 /*
 ******************************************************************************
 *
-*   Copyright (C) 1999-2013, International Business Machines
+*   Copyright (C) 1999-2014, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *
 ******************************************************************************
 *   file name:  ubidiimp.h
 *   encoding:   US-ASCII
 *   tab size:   8 (not used)
 *   indentation:4
 *
 *   created on: 1999aug06
 *   created by: Markus W. Scherer, updated by Matitiahu Allouche
 */
 
 #ifndef UBIDIIMP_H
 #define UBIDIIMP_H
 
-/* set import/export definitions */
+/*  set import/export definitions */
 #ifdef U_COMMON_IMPLEMENTATION
 
 #include "unicode/utypes.h"
 #include "unicode/uchar.h"
 #include "ubidi_props.h"
 
 /* miscellaneous definitions ---------------------------------------------- */
 
 typedef uint8_t DirProp;
 typedef uint32_t Flags;
@@ skipping 19 matching lines @@
     AL= U_RIGHT_TO_LEFT_ARABIC,         /* 13 */
     RLE=U_RIGHT_TO_LEFT_EMBEDDING,      /* 14 */
     RLO=U_RIGHT_TO_LEFT_OVERRIDE,       /* 15 */
     PDF=U_POP_DIRECTIONAL_FORMAT,       /* 16 */
     NSM=U_DIR_NON_SPACING_MARK,         /* 17 */
     BN= U_BOUNDARY_NEUTRAL,             /* 18 */
     FSI=U_FIRST_STRONG_ISOLATE,         /* 19 */
     LRI=U_LEFT_TO_RIGHT_ISOLATE,        /* 20 */
     RLI=U_RIGHT_TO_LEFT_ISOLATE,        /* 21 */
     PDI=U_POP_DIRECTIONAL_ISOLATE,      /* 22 */
-    ENL,                                /* 23 */
-    ENR,                                /* 24 */
+    ENL,    /* EN after W7 */           /* 23 */
+    ENR,    /* EN not subject to W7 */  /* 24 */
     dirPropCount
 };
 
-/*
- * Sometimes, bit values are more appropriate
- * to deal with directionality properties.
- * Abbreviations in these macro names refer to names
- * used in the BiDi algorithm.
- */
+/*  Sometimes, bit values are more appropriate
+    to deal with directionality properties.
+    Abbreviations in these macro names refer to names
+    used in the BiDi algorithm.
+*/
 #define DIRPROP_FLAG(dir) (1UL<<(dir))
+#define PURE_DIRPROP(prop)  ((prop)&~0xE0)    ?????????????????????????
 
 /* special flag for multiple runs from explicit embedding codes */
 #define DIRPROP_FLAG_MULTI_RUNS (1UL<<31)
 
 /* are there any characters that are LTR or RTL? */
-#define MASK_LTR (DIRPROP_FLAG(L)|DIRPROP_FLAG(EN)|DIRPROP_FLAG(AN)|DIRPROP_FLAG(LRE)|DIRPROP_FLAG(LRO)|DIRPROP_FLAG(LRI))
+#define MASK_LTR (DIRPROP_FLAG(L)|DIRPROP_FLAG(EN)|DIRPROP_FLAG(ENL)|DIRPROP_FLAG(ENR)|DIRPROP_FLAG(AN)|DIRPROP_FLAG(LRE)|DIRPROP_FLAG(LRO)|DIRPROP_FLAG(LRI))
 #define MASK_RTL (DIRPROP_FLAG(R)|DIRPROP_FLAG(AL)|DIRPROP_FLAG(RLE)|DIRPROP_FLAG(RLO)|DIRPROP_FLAG(RLI))
 #define MASK_R_AL (DIRPROP_FLAG(R)|DIRPROP_FLAG(AL))
 #define MASK_STRONG_EN_AN (DIRPROP_FLAG(L)|DIRPROP_FLAG(R)|DIRPROP_FLAG(AL)|DIRPROP_FLAG(EN)|DIRPROP_FLAG(AN))
 
 /* explicit embedding codes */
 #define MASK_EXPLICIT (DIRPROP_FLAG(LRE)|DIRPROP_FLAG(LRO)|DIRPROP_FLAG(RLE)|DIRPROP_FLAG(RLO)|DIRPROP_FLAG(PDF))
 
 /* explicit isolate codes */
 #define MASK_ISO (DIRPROP_FLAG(LRI)|DIRPROP_FLAG(RLI)|DIRPROP_FLAG(FSI)|DIRPROP_FLAG(PDI))
 
 #define MASK_BN_EXPLICIT (DIRPROP_FLAG(BN)|MASK_EXPLICIT)
 
 /* paragraph and segment separators */
 #define MASK_B_S (DIRPROP_FLAG(B)|DIRPROP_FLAG(S))
 
 /* all types that are counted as White Space or Neutral in some steps */
 #define MASK_WS (MASK_B_S|DIRPROP_FLAG(WS)|MASK_BN_EXPLICIT|MASK_ISO)
 
 /* types that are neutrals or could becomes neutrals in (Wn) */
 #define MASK_POSSIBLE_N (DIRPROP_FLAG(ON)|DIRPROP_FLAG(CS)|DIRPROP_FLAG(ES)|DIRPROP_FLAG(ET)|MASK_WS)
 
 /*
- * These types may be changed to "e",
- * the embedding type (L or R) of the run,
- * in the BiDi algorithm (N2)
+ *  These types may be changed to "e",
+ *  the embedding type (L or R) of the run,
+ *  in the BiDi algorithm (N2)
  */
 #define MASK_EMBEDDING (DIRPROP_FLAG(NSM)|MASK_POSSIBLE_N)
 
 /* the dirProp's L and R are defined to 0 and 1 values in UCharDirection */
 #define GET_LR_FROM_LEVEL(level) ((DirProp)((level)&1))
 
 #define IS_DEFAULT_LEVEL(level) ((level)>=0xfe)
 
 /*
- * The following bit is ORed to the property of directional control
- * characters which are ignored: unmatched PDF or PDI; LRx, RLx or FSI
- * which would exceed the maximum explicit bidi level.
- */
-#define IGNORE_CC   0x40
-
-#define PURE_DIRPROP(prop)  ((prop)&~IGNORE_CC)
-
-/*
- * The following bit is used for the directional isolate status.
- * Stack entries corresponding to isolate sequences are greater than ISOLATE.
+ *  The following bit is used for the directional isolate status.
+ *  Stack entries corresponding to isolate sequences are greater than ISOLATE.
  */
 #define ISOLATE  0x0100
 
 U_CFUNC UBiDiLevel
 ubidi_getParaLevelAtIndex(const UBiDi *pBiDi, int32_t index);
 
 #define GET_PARALEVEL(ubidi, index) \
             ((UBiDiLevel)(!(ubidi)->defaultParaLevel || (index)<(ubidi)->paras[0].limit ? \
                          (ubidi)->paraLevel : ubidi_getParaLevelAtIndex((ubidi), (index))))
 
 /* number of paras entries allocated initially without malloc */
-#define SIMPLE_PARAS_SIZE   10
+#define SIMPLE_PARAS_COUNT      10
 /* number of isolate entries allocated initially without malloc */
-#define SIMPLE_ISOLATES_SIZE 5
+#define SIMPLE_ISOLATES_COUNT   5
 /* number of isolate run entries for paired brackets allocated initially without malloc */
-#define SIMPLE_OPENINGS_SIZE 20
+#define SIMPLE_OPENINGS_COUNT   20
 
 #define CR  0x000D
 #define LF  0x000A
 
 /* Run structure for reordering --------------------------------------------- */
 enum {
     LRM_BEFORE=1,
     LRM_AFTER=2,
     RLM_BEFORE=4,
     RLM_AFTER=8
@@ skipping 12 matching lines @@
 typedef struct Opening {
     int32_t position;                   /* position of opening bracket */
     int32_t match;                      /* matching char or -position of closing bracket */
     int32_t contextPos;                 /* position of last strong char found before opening */
     uint16_t flags;                     /* bits for L or R/AL found within the pair */
     UBiDiDirection contextDir;          /* L or R according to last strong char before opening */
     uint8_t filler;                     /* to complete a nice multiple of 4 chars */
 } Opening;
 
 typedef struct IsoRun {
-    int32_t  lastStrongPos;             /* position of last strong char found in this run */
-    int32_t  contextPos;                /* position of last char defining context */
+    int32_t  contextPos;                /* position of char determining context */
     uint16_t start;                     /* index of first opening entry for this run */
     uint16_t limit;                     /* index after last opening entry for this run */
     UBiDiLevel level;                   /* level of this run */
     DirProp lastStrong;                 /* bidi class of last strong char found in this run */
+    DirProp lastBase;                   /* bidi class of last base char found in this run */
     UBiDiDirection contextDir;          /* L or R to use as context for following openings */
-    uint8_t filler;                     /* to complete a nice multiple of 4 chars */
 } IsoRun;
 
 typedef struct BracketData {
     UBiDi   *pBiDi;
     /* array of opening entries which should be enough in most cases; no malloc() */
-    Opening simpleOpenings[SIMPLE_OPENINGS_SIZE];
+    Opening simpleOpenings[SIMPLE_OPENINGS_COUNT];
     Opening *openings;                  /* pointer to current array of entries */
     int32_t openingsCount;              /* number of allocated entries */
     int32_t isoRunLast;                 /* index of last used entry */
     /* array of nested isolated sequence entries; can never excess UBIDI_MAX_EXPLICIT_LEVEL
        + 1 for index 0, + 1 for before the first isolated sequence */
     IsoRun  isoRuns[UBIDI_MAX_EXPLICIT_LEVEL+2];
     UBool isNumbersSpecial;             /* reordering mode for NUMBERS_SPECIAL */
 } BracketData;
 
 typedef struct Isolate {
+    int32_t startON;
     int32_t start1;
     int16_t stateImp;
     int16_t state;
 } Isolate;
 
 typedef struct Run {
     int32_t logicalStart,   /* first character of the run; b31 indicates even/odd level */
             visualLimit,    /* last visual position of the run +1 */
             insertRemove;   /* if >0, flags for inserting LRM/RLM before/after run,
                                if <0, count of bidi controls within run            */
@@ skipping 142 matching lines @@
     /* characters after trailingWSStart are WS and are */
     /* implicitly at the paraLevel (rule (L1)) - levels may not reflect that */
     int32_t trailingWSStart;
 
     /* fields for paragraph handling */
     int32_t paraCount;                  /* set in getDirProps() */
     /* filled in getDirProps() */
     Para *paras;
 
     /* for relatively short text, we only need a tiny array of paras (no malloc()) */
-    Para simpleParas[SIMPLE_PARAS_SIZE];
+    Para simpleParas[SIMPLE_PARAS_COUNT];
 
     /* fields for line reordering */
     int32_t runCount;     /* ==-1: runs not set up yet */
     Run *runs;
 
     /* for non-mixed text, we only need a tiny array of runs (no malloc()) */
     Run simpleRuns[1];
 
     /* maximum or current nesting depth of isolate sequences */
     /* Within resolveExplicitLevels() and checkExplicitLevels(), this is the maximal
        nesting encountered.
        Within resolveImplicitLevels(), this is the index of the current isolates
        stack entry. */
     int32_t isolateCount;
     Isolate *isolates;
 
     /* for simple text, have a small stack (no malloc()) */
-    Isolate simpleIsolates[SIMPLE_ISOLATES_SIZE];
+    Isolate simpleIsolates[SIMPLE_ISOLATES_COUNT];
 
     /* for inverse Bidi with insertion of directional marks */
     InsertPoints insertPoints;
 
     /* for option UBIDI_OPTION_REMOVE_CONTROLS */
     int32_t controlCount;
 
     /* for Bidi class callback */
     UBiDiClassCallback *fnClassCallback;    /* action pointer */
     const void *coClassCallback;            /* context pointer */
@@ skipping 86 matching lines @@
         ubidi_getMemory((BidiMemoryForAllocation *)&(pBiDi)->runsMemory, &(pBiDi)->runsSize, \
                         TRUE, (length)*sizeof(Run))
 
 #define getInitialIsolatesMemory(pBiDi, length) \
         ubidi_getMemory((BidiMemoryForAllocation *)&(pBiDi)->isolatesMemory, &(pBiDi)->isolatesSize, \
                         TRUE, (length)*sizeof(Isolate))
 
 #endif
 
 #endif