*** empty log message ***

[m17n/m17n-lib-cs.git] / MText.cs

diff --git a/MText.cs b/MText.cs
index 50b573c..98cb0c5 100644 (file)
--- a/MText.cs
+++ b/MText.cs
@@ -53,7 +53,6 @@ namespace M17N.Core
     {
       this.key = key;
       this.val = val;
-      flags |= Flag.RearSticky;
     }
 
     public MTextProperty (MSymbol key, object val,
@@ -252,6 +251,8 @@ namespace M17N.Core
     {
       check_pos (pos, true);
 
+      if (from == to)
+       return;
       int pos_idx = pos_to_idx (this, pos);
       int from_idx = pos_to_idx (mt2, from);
       int to_idx = pos_to_idx (mt2, to);
@@ -596,12 +597,22 @@ namespace M17N.Core
 
       private MInterval LeftMost
       {
-       get { return (Left == null ? this : Left.LeftMost); }
+       get {
+         if (Left == null)
+           return this;
+         Left.update_from_to ();
+         return Left.LeftMost;
+       }
       }
 
       private MInterval RightMost
       {
-       get { return (Right == null ? this : Right.RightMost); }
+       get {
+         if (Right == null)
+           return this;
+         Right.update_from_to ();
+         return Right.RightMost;
+       }
       }
 
       private MInterval Prev {
@@ -609,12 +620,14 @@ namespace M17N.Core
          MInterval i;
 
          if (Left != null)
-           for (i = Left; i.Right != null; i = i.Right);
+           for (i = Left; i.Right != null; i = i.Right)
+             i.update_from_to ();
          else
            {
              MInterval child = this;
              for (i = Parent; i != null && i.Left == child;
-                  child = i, i = i.Parent);
+                  child = i, i = i.Parent)
+               i.update_from_to ();
            }
          return i;
        }
@@ -625,12 +638,14 @@ namespace M17N.Core
          MInterval i;
 
          if (Right != null)
-           for (i = Right; i.Left != null; i = i.Left);
+           for (i = Right; i.Left != null; i = i.Left)
+             i.update_from_to ();
          else
            {
              MInterval child = this;
              for (i = Parent; i != null && i.Right == child;
-                  child = i, i = i.Parent);
+                  child = i, i = i.Parent)
+               i.update_from_to ();
            }
          return i;
        }
@@ -978,7 +993,7 @@ namespace M17N.Core
       {
        update_from_to ();
        M17N.DebugPrint ("insert({0}) at {1} in ", interval.Length, pos);
-       DumpOne (false, true);
+       DumpOne (false, false);
 
        interval.set_mtext (mtext);
 
@@ -1097,11 +1112,20 @@ namespace M17N.Core
          }
        else                    // (pos > To)
          Next.Insert (pos, interval);
+       M17N.DebugPrint (" done\n");
       }
 
       private void vacate_node (MInterval interval)
       {
-       M17N.DebugPrint ("vacate #{0} to #{1}", ID, interval.ID);
+       vacate_node (interval, null);
+      }
+
+      private void vacate_node (MInterval interval, MInterval stop)
+      {
+       if (interval != null)
+         M17N.DebugPrint ("vacate #{0} to #{1}\n", ID, interval.ID);
+       else
+         M17N.DebugPrint ("vacate #{0} to null\n", ID);
        if (interval != null)
          interval.Parent = Parent;
        if (Parent == null)
@@ -1119,7 +1143,7 @@ namespace M17N.Core
            int diff = Length;
            if (interval != null)
              diff -= interval.Length;
-           for (MInterval i = Parent; i != null; i = i.Parent)
+           for (MInterval i = Parent; i != stop; i = i.Parent)
              i.Length -= diff;
          }
       }
@@ -1215,83 +1239,47 @@ namespace M17N.Core
       private static void merge_nodes (MInterval head, MInterval tail)
       {
        M17N.DebugPrint ("merging "); head.DumpOne (true, false);
-       M17N.DebugPrint (" through "); tail.DumpOne (true, true);
+       M17N.DebugPrint (" through "); tail.DumpOne (true, false);
 
        int from = head.From;
        int to = tail.To;
        MInterval root;
 
-       for (root = head; root.To + head.RightLength < to;
+       for (root = head; root.To + root.RightLength < to;
             root = root.Parent);
        
-       M17N.DebugPrint ("common root is "); root.DumpOne (false, true);
+       M17N.DebugPrint (" common root is "); root.DumpOne (false, true);
 
        if (from < root.From)
          {
            MInterval prev = root.Prev;
-           int deleting = root.From - from;
-           int deleted = 0;
 
-           while (deleted < deleting)
+           while (true)
              {
-               int len = prev.Length - prev.LeftLength;
-
                M17N.DebugPrint ("merging "); prev.DumpOne (false, true);
-               deleted += len;
+               prev.vacate_node (prev.Left, root);
+               if (prev == head)
+                 break;
                if (prev.Left != null)
-                 {
-                   prev.Left.Parent = prev.Parent;
-                   if (prev.Parent.Right == prev)
-                     prev.Parent.Right = prev.Left;
-                   else
-                     prev.Parent.Left = prev.Left;
-                   prev = prev.Left.RightMost;
-                 }
+                 prev = prev.Left.RightMost;
                else
-                 {
-                   prev = prev.Parent;
-                   prev.Right = null;
-                   prev.Length -= deleted;
-                 }
-             }
-           while (prev.Parent != root)
-             {
-               prev.Length -= deleted;
-               prev = prev.Parent;
+                 prev = prev.Parent;
              }
          }
        if (root.To < to)
          {
            MInterval next = root.Next;
-           int deleting = root.To - to;
-           int deleted = 0;
 
-           while (deleted < deleting)
+           while (true)
              {
-               int len = next.Length - next.RightLength;
-
                M17N.DebugPrint ("merging "); next.DumpOne (false, true);
-               deleted += len;
+               next.vacate_node (next.Right, root);
+               if (next == tail)
+                 break;
                if (next.Right != null)
-                 {
-                   next.Right.Parent = next.Parent;
-                   if (next.Parent.Left == next)
-                     next.Parent.Left = next.Right;
-                   else
-                     next.Parent.Right = next.Right;
-                   next = next.Right.LeftMost;
-                 }
+                 next = next.Right.LeftMost;
                else
-                 {
-                   next = next.Parent;
-                   next.Left = null;
-                   next.Length -= deleted;
-                 }
-             }
-           while (next.Parent != root)
-             {
-               next.Length -= deleted;
-               next = next.Parent;
+                 next = next.Parent;
              }
          }
       }