Move SOS calculation into push/pop embedding level; fix N1/N2 w/isolates.

1 files changed, 24 insertions, 10 deletions

diff --git a/src/bidi.c b/src/bidi.c
index eee2a9c623b..c7a66198ff9 100644
--- a/src/bidi.c
+++ b/src/bidi.c
@@ -423,6 +423,7 @@ bidi_push_embedding_level (struct bidi_it *bidi_it,
 			   int level, bidi_dir_t override, bool isolate_status)
 {
   struct bidi_stack *st;
+  int prev_level = bidi_it->level_stack[bidi_it->stack_idx].level;
 
   bidi_it->stack_idx++;
   eassert (bidi_it->stack_idx < BIDI_MAXDEPTH+2+1);
@@ -438,6 +439,9 @@ bidi_push_embedding_level (struct bidi_it *bidi_it,
       st->next_for_neutral = bidi_it->next_for_neutral;
       st->sos = bidi_it->sos;
     }
+  /* We've got a new isolating sequence, compute the directional type
+     of sos and initialize per-sequence variables (UAX#9, clause X10).  */
+  bidi_set_sos_type (bidi_it, prev_level, level);
 }
 
 /* Pop from the stack the embedding level, the directional override
@@ -454,6 +458,8 @@ bidi_pop_embedding_level (struct bidi_it *bidi_it)
     {
       bool isolate_status
 	= bidi_it->level_stack[bidi_it->stack_idx].isolate_status;
+      int old_level = bidi_it->level_stack[bidi_it->stack_idx].level;
+
       struct bidi_stack st;
 
       st = bidi_it->level_stack[bidi_it->stack_idx];
@@ -473,6 +479,10 @@ bidi_pop_embedding_level (struct bidi_it *bidi_it)
 	  bidi_it->next_for_neutral = st.next_for_neutral;
 	  bidi_it->sos = st.sos;
 	}
+      else
+	bidi_set_sos_type (bidi_it, old_level,
+			   bidi_it->level_stack[bidi_it->stack_idx - 1].level);
+
       bidi_it->stack_idx--;
     }
   level = bidi_it->level_stack[bidi_it->stack_idx].level;
@@ -1996,14 +2006,7 @@ bidi_resolve_weak (struct bidi_it *bidi_it)
 	     || type == PDF));
 
   eassert (prev_level >= 0);
-  if (new_level > prev_level
-      /* When the embedding level goes down, we only need to compute
-	 the type of sos if this level is not an isolate, because the
-	 sos type of the isolating sequence was already computed and
-	 saved on the stack.  */
-      || (new_level < prev_level
-	  && !bidi_it->level_stack[bidi_it->stack_idx].isolate_status)
-      || bidi_it->type == NEUTRAL_B)
+  if (bidi_it->type == NEUTRAL_B)
     {
       /* We've got a new isolating sequence, compute the directional
          type of sos and initialize per-run variables (UAX#9, clause
@@ -2336,6 +2339,8 @@ bidi_resolve_neutral (struct bidi_it *bidi_it)
 	     are dealing with now.  We also cache the scanned iterator
 	     states, to salvage some of the effort later.  */
 	  do {
+	    int old_sidx, new_sidx;
+
 	    /* Paragraph separators have their levels fully resolved
 	       at this point, so cache them as resolved.  */
 	    bidi_cache_iterator_state (bidi_it, type == NEUTRAL_B);
@@ -2344,10 +2349,19 @@ bidi_resolve_neutral (struct bidi_it *bidi_it)
 	    if (bidi_it->type_after_w1 != WEAK_BN /* W1/Retaining */
 		&& bidi_it->type != WEAK_BN)
 	      bidi_remember_char (&bidi_it->prev, bidi_it);
+	    old_sidx = bidi_it->stack_idx;
 	    type = bidi_resolve_weak (bidi_it);
 	    /* Skip level runs excluded from this isolating run sequence.  */
-	    if (bidi_it->level_stack[bidi_it->stack_idx].level > current_level
-		&& bidi_it->level_stack[bidi_it->stack_idx].isolate_status)
+	    new_sidx = bidi_it->stack_idx;
+	    if (bidi_it->level_stack[new_sidx].level > current_level
+		&& (bidi_it->level_stack[new_sidx].isolate_status
+		    /* This is for when we have an isolate initiator
+		       immediately followed by an embedding or
+		       override initiator, in which case we get the
+		       level stack pushed twice by the single call to
+		       bidi_resolve_weak above.  */
+		    || (new_sidx > old_sidx + 1
+			&& bidi_it->level_stack[new_sidx - 1].isolate_status)))
 	      {
 		while (bidi_it->level_stack[bidi_it->stack_idx].level
 		       > current_level)