*** empty log message ***
[m17n/m17n-lib-cs.git] / MText.cs
index 5c9c778..f8d7379 100644 (file)
--- a/MText.cs
+++ b/MText.cs
@@ -24,26 +24,29 @@ namespace M17N.Core
     [FlagsAttribute]
     public enum Flags
     {
-      None =           0,
+      None =           0x00,
       /// A text inserted before a character that has this property
       /// inherits this property.  If the text already has properties
-      /// of the same key, they are deleted.  See the documentation of
-      /// Sensitive for exception.
-      FrontSticky =    1,
+      /// of the same key, they are deleted.
+      FrontSticky =    0x01,
       /// A text inserted after a character that has this property
       /// inherits this property.  If the text already has properties
-      /// of the same key, they are deleted.  See the documentation of
-      /// Sensitive for exception.
-      RearSticky =     2,
+      /// of the same key, they are deleted.
+      RearSticky =     0x02,
       /// This property is deleted from a span of text if the span is
       /// modified (i.e. a character is changed, a text is inserted,
       /// some part is deleted).  This propery is also deleted if a
       /// property of the same key is added, which means that this
-      /// property is not stackable.  If this property is also
-      /// FrontSticky (or RearSticky), text insertion just before (or
-      /// after) the span also deletes this property from the span of
-      /// text.
-      Sensitive =      4,
+      /// property is not stackable.
+      Sensitive =      0x04,
+      /// Like Sensitive but also this property is deleted from a span
+      /// of text if a text just before the span is modified,
+      /// inserted, or deleted.
+      FrontSensitive = 0x0C,
+      /// Like Sensitive but also this property is deleted from a span
+      /// of text if a text just after the span is modified, inserted,
+      /// or deleted.
+      RearSensitive =  0x14
     };
 
     internal MSymbol key;
@@ -55,7 +58,7 @@ namespace M17N.Core
     public MProperty (MSymbol key, object val)
     {
       if (key.flags == null)
-       key.flags = MProperty.Flags.None;
+       key.flags = Flags.None;
       this.key = key;
       this.val = val;
     }
@@ -66,6 +69,11 @@ namespace M17N.Core
       this.val = val;
     }
 
+    public static bool HasFlags (MSymbol key, Flags flags)
+    {
+      return ((key.flags & flags) == flags);
+    }
+
     public override string ToString ()
     {
       return key.ToString () + ":" + val;
@@ -137,27 +145,27 @@ namespace M17N.Core
     public static MText operator+ (object obj, MText mt)
     {
       if (obj is string)
-       return new MText ((string) obj) + mt;
+       {
+         MText mtnew = new MText ((string) obj);
+         return mtnew.Ins (mtnew.Length, mt);
+       }
       throw new Exception ("Unknown object type: " + obj.GetType());
     }
 
-    public static MText operator+ (MText mt1, MText mt2)
+    public static MText operator+ (MText mt, object obj)
     {
-      MText mt = new MText ();
-
-      mt.sb.Append (mt1.sb);
-      mt.sb.Append (mt2.sb);
-      mt.nchars = mt1.nchars + mt2.nchars;
-      return mt;
+      if (obj is string)
+       return mt + new MText ((string) obj);
+      if (obj is int)
+       return mt.Dup ().Ins (mt.Length, (int) obj);
+      if (obj is char)
+       return mt.Dup ().Ins (mt.Length, (int) ((char) obj));
+      throw new Exception ("Unknown object type: " + obj.GetType());
     }
 
-    public static MText operator+ (string str, MText mt)
+    public static MText operator+ (MText mt1, MText mt2)
     {
-      MText mtnew = new MText (str);
-
-      mtnew.sb.Append (mt.sb);
-      mtnew.nchars += mt.nchars;
-      return mtnew;
+      return mt1.Dup ().Ins (mt1.Length, mt2);
     }
 
     // Public properties
@@ -415,7 +423,7 @@ namespace M17N.Core
            MInterval root = (MInterval) plist.Val;
            root.Delete (from, to);
            if (from > 0 && from < nchars)
-             root.MergeAfterChange (from, from);
+             ((MInterval) plist.Val).MergeAfterChange (from, from);
          }
       else
        intervals.Clear ();
@@ -521,6 +529,9 @@ namespace M17N.Core
                root.PopSensitive (from, to);
              else
                root.Pop (from, to);
+             root = (MInterval) p.Val;
+             if (M17n.debug)
+               DumpPropNested ();
              root.MergeAfterChange (from, to);
              root.Balance ();
            }
@@ -627,20 +638,29 @@ namespace M17N.Core
 
       private bool isRearSticky
       {
-       get { return ((Key.flags & MProperty.Flags.RearSticky)
-                     != MProperty.Flags.None); }
+       get { return MProperty.HasFlags (Key, MProperty.Flags.RearSticky) ; }
       }
 
       private bool isFrontSticky
       {
-       get { return ((Key.flags & MProperty.Flags.FrontSticky)
-                     != MProperty.Flags.None); }
+       get { return MProperty.HasFlags (Key, MProperty.Flags.FrontSticky) ; }
       }
 
       public bool isSensitive
       {
-       get { return ((Key.flags & MProperty.Flags.Sensitive)
-                     != MProperty.Flags.None); }
+       get { return MProperty.HasFlags (Key, MProperty.Flags.Sensitive) ; }
+      }
+
+      public bool isFrontSensitive
+      {
+       get { return MProperty.HasFlags (Key,
+                                        MProperty.Flags.FrontSensitive) ; }
+      }
+
+      public bool isRearSensitive
+      {
+       get { return MProperty.HasFlags (Key,
+                                        MProperty.Flags.RearSensitive) ; }
       }
 
       private void update_from_to ()
@@ -793,6 +813,7 @@ namespace M17N.Core
        if (c1 != null)
          c1.Parent = this;
 
+       Parent.update_from_to ();
        return Parent;
       }
 
@@ -826,6 +847,7 @@ namespace M17N.Core
        if (c2 != null)
          c2.Parent = this;
 
+       Parent.update_from_to ();
        return Parent;
       }
 
@@ -833,6 +855,7 @@ namespace M17N.Core
       {
        MInterval i = this;
 
+       update_from_to ();
        while (true)
          {
            //       .-this-.
@@ -1048,119 +1071,137 @@ namespace M17N.Core
          Left.Insert (pos, interval, start, end);
        else if (pos == From)
          {
-           if (Left != null)
-             {
-               MInterval prev = Prev;
+           MInterval prev = Left != null ? Prev : null;
 
-               if (prev.isSensitive && prev.isRearSticky)
-                 prev.Stack.Clear ();
-               start += prev.graft_forward (interval, start, end);
-             }
-           if (isSensitive && isFrontSticky)
+           if (isFrontSensitive)
              Stack.Clear ();
-           if (start < end)
+           if (prev != null && isRearSensitive)
+             prev.Stack.Clear ();
+           if (prev != null && isRearSticky && ! prev.Stack.IsEmpty)
              {
-               end -= graft_backward (interval, start, end);
-               if (start < end)
-                 {
-                   if (interval != null)
-                     interval = interval.Copy (mtext, start, end);
-                   else
-                     interval = new MInterval (Key, mtext, end - start, null);
+               prev.enlarge (end - start);
+               return;
+             }
+           if (isFrontSticky && ! Stack.IsEmpty)
+             {
+               enlarge (end - start);
+               return;
+             }
+           if (prev != null)
+             {
+               start += prev.graft_forward (interval, start, end);
+               if (start == end)
+                 return;
+             }
+           if ((end -= graft_backward (interval, start, end)) == start)
+             return;
 
-                   MInterval i;
-                   if (Left != null)
-                     {
-                       //    .-this-.   ==>          .-this-.
-                       // left-.                 .-left-.
-                       //    child                     child-.
-                       //                                 interval
-                       i = Left.RightMost;
-                       i.Right = interval;
-                     }
-                   else
-                     {
-                       Left = interval;
-                       i = this;
-                     }
-                   interval.Parent = i;
-                   for (; i != null; i = i.Parent)
-                     i.Length += interval.Length;
-                 }
+           if (interval != null)
+             interval = interval.Copy (mtext, start, end);
+           else
+             interval = new MInterval (Key, mtext, end - start, null);
+
+           MInterval i;
+           if (Left != null)
+             {
+               //    .-this-.   ==>          .-this-.
+               // left-.                 .-left-.
+               //    child                     child-.
+               //                                 interval
+               i = Left.RightMost;
+               i.Right = interval;
+             }
+           else
+             {
+               Left = interval;
+               i = this;
              }
+           interval.Parent = i;
+           for (; i != null; i = i.Parent)
+             i.Length += interval.Length;
          }
        else if (pos < To)
          {
            if (isSensitive)
              Stack.Clear ();
-
+           else if (! Stack.IsEmpty && (isFrontSticky || isRearSticky))
+             {
+               enlarge (end - start);
+               return;
+             }
            int len = graft_forward (interval, start, end);
            start += len;
+           if (start == end)
+             return;
+           if ((end -= graft_backward (interval, start, end)) == start)
+             return;
            pos += len;
-           if (start < end)
+           if (interval != null)
+             interval = interval.Copy (mtext, start, end);
+           else
+             interval = new MInterval (Key, mtext, end - start, null);
+
+           divide_right (pos);
+           Right.Left = interval;
+           interval.Parent = Right;
+           for (MInterval i = Right; i != null; i = i.Parent)
+             i.Length += interval.Length;
+         }
+       else if (pos == To)
+         {
+           MInterval next = Right != null ? Next : null;
+
+           if (isRearSensitive)
+             Stack.Clear ();
+           if (next != null && isFrontSensitive)
+             next.Stack.Clear ();
+           if (isRearSticky && ! Stack.IsEmpty)
              {
-               end -= graft_backward (interval, start, end);
-               if (start < end)
+               enlarge (end - start);
+               return;
+             }
+           if (next != null)
+             {
+               if (isFrontSticky && ! next.Stack.IsEmpty)
                  {
-                   if (interval != null)
-                     interval = interval.Copy (mtext, start, end);
-                   else
-                     interval = new MInterval (Key, mtext, end - start, null);
-
-                   divide_right (pos);
-                   Right.Left = interval;
-                   interval.Parent = Right;
-                   for (MInterval i = Right; i != null; i = i.Parent)
-                     i.Length += interval.Length;
+                   next.enlarge (end - start);
+                   return;
                  }
+               end -= next.graft_backward (interval, start, end);
+               if (start == end)
+                 return;
              }
-         }
-       else if (pos == To)
-         {
+
+           if ((start += graft_forward (interval, start, end)) == end)
+             return;
+
+           if (interval != null)
+             interval = interval.Copy (mtext, start, end);
+           else
+             interval = new MInterval (Key, mtext, end - start, null);
+
+           MInterval i;
            if (Right != null)
              {
-               MInterval next = Next;
+               //    .-this-.   ==>          .-this-.
+               //         .-right                 .-right
+               //     child                  .-child
+               //                        interval
 
-               if (next.isSensitive && next.isFrontSticky)
-                 next.Stack.Clear ();
-               end -= next.graft_backward (interval, start, end);
+               i = Right.LeftMost;
+               i.Left = interval;
              }
-           if (isSensitive && isRearSticky)
-             Stack.Clear ();
-           if (start < end)
+           else
              {
-               start += graft_forward (interval, start, end);
-               if (start < end)
-                 {
-                   if (interval != null)
-                     interval = interval.Copy (mtext, start, end);
-                   else
-                     interval = new MInterval (Key, mtext, end - start, null);
-
-                   MInterval i;
-                   if (Right != null)
-                     {
-                       //    .-this-.   ==>          .-this-.
-                       //         .-right                 .-right
-                       //     child                  .-child
-                       //                        interval
-
-                       i = Right.LeftMost;
-                       i.Left = interval;
-                     }
-                   else
-                     {
-                       Right = interval;
-                       i = this;
-                     }
-                   interval.Parent = i;
-                   for (; i != null; i = i.Parent)
-                     i.Length += interval.Length;
-                 }
+               Right = interval;
+               i = this;
              }
+           interval.Parent = i;
+           for (; i != null; i = i.Parent)
+             i.Length += interval.Length;
          }
        else                    // (pos > To)
-         Next.Insert (pos, interval, start, end);
+         Right.Insert (pos, interval, start, end);
        M17n.DebugPrint (" done\n");
       }
 
@@ -1290,14 +1331,13 @@ namespace M17N.Core
       /// intervals are mergeable.
       private static void combine (MInterval head, MInterval tail)
       {
-       M17n.DebugPrint ("merging "); head.DumpOne (true, false);
+       M17n.DebugPrint ("combining "); head.DumpOne (true, false);
        M17n.DebugPrint (" through "); tail.DumpOne (true, false);
 
        int from = head.From;
        int to = tail.To;
        // The nearest common parent of HEAD and TAIL.
        MInterval root;
-
        for (root = head; root.To + root.RightLength < to;
             root = root.Parent);
        
@@ -1318,6 +1358,7 @@ namespace M17N.Core
                else
                  prev = prev.Parent;
              }
+           root.update_from_to ();
          }
        if (root.To < to)
          {
@@ -1334,6 +1375,7 @@ namespace M17N.Core
                else
                  next = next.Parent;
              }
+           root.update_from_to ();
          }
       }
 
@@ -1341,34 +1383,27 @@ namespace M17N.Core
       {
        update_from_to ();
 
-       MInterval head = find_head (start), tail = head, i;
+       MInterval head = find_head (start), i = head;
+       MInterval tail = find_tail (end).Next;
 
        if (start == head.From && start > 0)
          {
            i = head.Prev;
-           if (head.mergeable (i))
-             head = i;
+           if (! head.mergeable (i))
+             i = head;
          }
-       while (tail.To < end)
+       while (i != tail)
          {
-           i = tail.Next;
-           if (! tail.mergeable (i))
+           MInterval next = i.Next;
+
+           if (next == null || ! i.mergeable (next))
              {
-               if (head != tail)
-                 combine (head, tail);
-               head = i;
+               if (head != i)
+                 combine (head, i);
+               head = next;
              }
-           tail = i;
-         }
-       while (true)
-         {
-           i = tail.Next;
-           if (i == null || ! tail.mergeable (i))
-             break;
-           tail = i;
+           i = next;
          }
-       if (head != tail)
-         combine (head, tail);
       }
 
       public void Pop (int start, int end)
@@ -1440,9 +1475,16 @@ namespace M17N.Core
        if (force || M17n.debug)
          {
            Console.Write ("#{0}({1} {2} {3}", ID, Length, From, To);
-           if (with_prop)
-             foreach (MPlist p in Stack)
-               Console.Write (" " + p.Val);
+           if (with_prop && ! Stack.IsEmpty)
+             {
+               string prepend = " [";
+               foreach (MPlist p in Stack)
+                 {
+                   Console.Write (prepend + ((MProperty) p.Val).Val);
+                   prepend = " ";
+                 }
+               Console.Write ("]");
+             }
            Console.Write (")");
            if (newline)
              Console.WriteLine ();