*** empty log message ***

diff --git a/MSymbol.cs b/MSymbol.cs
index c41fda9..563feb0 100644 (file)
--- a/MSymbol.cs
+++ b/MSymbol.cs
@@ -53,6 +53,9 @@ namespace M17N.Core
     {
       MSymbol sym = MSymbol.Of (name);
 
+      if ((flags & MProperty.Flags.BothSticky) != MProperty.Flags.None
+         && (flags & MProperty.Flags.Sensitive) != MProperty.Flags.None)
+       throw new Exception ("Sensitive property can't be sticky");
       if (sym.flags == null)
        sym.flags = flags;
       else if (sym.flags != flags)

diff --git a/MText.cs b/MText.cs
index beff7e5..03aa654 100644 (file)
--- a/MText.cs
+++ b/MText.cs
@@ -26,34 +26,51 @@ namespace M17N.Core
     {
       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 at first.
-      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 at first.
-      RearSticky =     0x02,
+      /// On inserting a text in between two characters, if the
+      /// preceding and following characters have Sticky properties of
+      /// the same key with same values, the inserted text inherits
+      /// those properties.  In that case, properties of the inserted
+      /// text are overriden.
+      Sticky =         0x01,   // 00000001
+
+      /// On inserting a text before a character, if the character has
+      /// FrontSticky properties, the inserted text inherits those
+      /// properties.
+      FrontSticky =    0x03,   // 00000011
+
+      /// On inserting a text after a character, if the character has
+      /// RearSticky properties, the inserted text inherits those
+      /// properties.
+      RearSticky =     0x05,   // 00000101
+
+      /// Like RearSticky, but if the inserted text inherits no
+      /// properties from the preceding character, it inherits
+      /// BothSticky properties from the following character if any.
+      BothSticky =     0x07,   // 00000111
 
       /// 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 property is also deleted if a
-      /// property of the same key is added, which means that this
-      /// property is not stackable.  In addition this property is
-      /// never merged with the same value of preceding or following
-      /// property.
-      Sensitive =      0x04,
+      /// modified (i.e. one of a character is changed, a text is
+      /// inserted, some part is deleted).  Here, "span" means a
+      /// sequence of characters that has this property with the same
+      /// value.  This property is also deleted if a property of the
+      /// same key is added, which means that this property is not
+      /// stackable.  In addition this property is never merged with
+      /// the same value of preceding or following property.  At last,
+      /// this property can't be sticky in any way.
+      Sensitive =      0x10,   // 00010000
 
       /// Like Sensitive but also this property is deleted from a span
-      /// of text if a text just before the span is modified,
+      /// of text if a characeter just before the span is modified,
       /// inserted, or deleted.
-      FrontSensitive = 0x0C,
+      FrontSensitive = 0x30,   // 00110000
 
       /// 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,
+      /// of text if a character just after the span is modified,
+      /// inserted, or deleted.
+      RearSensitive =  0x50,   // 01010000
+
+      /// Same as (FrontSensitive | RearSensitive).
+      BothSensitive =  0x70,   // 01110000
     };
 
     internal MSymbol key;
@@ -78,7 +95,7 @@ namespace M17N.Core
 
     public static bool HasFlags (MSymbol key, Flags flags)
     {
-      return ((key.flags & flags) != Flags.None);
+      return ((key.flags & flags) == flags);
     }
 
     public override string ToString ()
@@ -783,6 +800,10 @@ namespace M17N.Core
       {
        MPlist p1, p2;
 
+       if (Stack.IsEmpty && i.Stack.IsEmpty)
+         return true;
+       if (isSensitive)
+         return false;
        for (p1 = Stack, p2 = i.Stack; ! p1.IsEmpty && ! p2.IsEmpty;
             p1 = p1.Next, p2 = p2.Next)
          if (p1.Val != p2.Val)
@@ -942,14 +963,14 @@ namespace M17N.Core
        MInterval tail = find_tail (end);
 
        if (! head.Stack.IsEmpty
-           && ((isSensitive || isFrontSensitive) && head.From < start
+           && (isSensitive && head.From < start
                || isFrontSensitive && ! first))
          {
            head = copy.find_head (0);
            head.Stack.Clear ();
          }
        if (! tail.Stack.IsEmpty
-           && ((isSensitive || isRearSensitive) && end < head.To
+           && (isSensitive && end < head.To
                || isRearSensitive && ! last))
          {
            tail = copy.find_tail (copy.Length);
@@ -1038,10 +1059,9 @@ namespace M17N.Core
 
            len = 0;
            if (Stack.IsEmpty
-               && (isFrontSensitive
-                   || ((isSensitive || isRearSensitive) && i.From < start)))
+               && (isFrontSensitive || (isSensitive && i.From < start)))
              {
-               M17n.DebugPrint (" grafting {0}", i);
+               M17n.DebugPrint (" forward grafting {0}", i);
                if (i.To < end)
                  len = i.To - start;
                else
@@ -1050,7 +1070,7 @@ namespace M17N.Core
              }
            while (i != null && i.From < end && mergeable (i))
              {
-               M17n.DebugPrint (" grafting {0}", i);
+               M17n.DebugPrint (" forward grafting {0}", i);
                len += i.To - i.From;
                if (i.From < start)
                  len -= start - i.From;
@@ -1083,10 +1103,9 @@ namespace M17N.Core
 
            len = 0;
            if (Stack.IsEmpty
-               && (isRearSensitive
-                   || ((isSensitive || isFrontSensitive) && end < i.To)))
+               && (isRearSensitive || (isSensitive && end < i.To)))
              {
-               M17n.DebugPrint (" grafting {0}", i);
+               M17n.DebugPrint (" backward grafting {0}", i);
                if (i.From <= start)
                  len = end - start;
                else
@@ -1095,7 +1114,7 @@ namespace M17N.Core
              }
            while (i != null && i.To <= start && mergeable (i))
              {
-               M17n.DebugPrint (" grafting {0}", i);
+               M17n.DebugPrint (" backward grafting {0}", i);
                len += i.To - i.From;
                if (end < i.To)
                  len -= i.To - end;
@@ -1134,11 +1153,13 @@ namespace M17N.Core
            if (prev != null && isRearSticky && ! prev.Stack.IsEmpty)
              {
                prev.enlarge (end - start);
+               M17n.DebugPrint (" done\n");
                return;
              }
            if (isFrontSticky && ! Stack.IsEmpty)
              {
                enlarge (end - start);
+               M17n.DebugPrint (" done\n");
                return;
              }
            bool front_grafted = false, rear_grafted = false;
@@ -1148,14 +1169,20 @@ namespace M17N.Core
              {
                start += grafted;
                if (start == end)
-                 return;
+                 {
+                   M17n.DebugPrint (" done\n");
+                   return;
+                 }
                front_grafted = true;
              }
            if ((grafted = graft_backward (interval, start, end)) > 0)
              {
                end -= grafted;
                if (start == end)
-                 return;
+                 {
+                   M17n.DebugPrint (" done\n");
+                   return;
+                 }
                rear_grafted = true;
              }
 
@@ -1190,7 +1217,7 @@ namespace M17N.Core
          {
            if (! Stack.IsEmpty)
              {
-               if (isSensitive || isFrontSensitive || isRearSensitive)
+               if (isSensitive)
                  Stack.Clear ();
                else if (isFrontSticky || isRearSticky)
                  {
@@ -1204,7 +1231,10 @@ namespace M17N.Core
              {
                start += grafted;
                if (start == end)
-                 return;
+                 {
+                   M17n.DebugPrint (" done\n");
+                   return;
+                 }
                front_grafted = true;
                pos += grafted;
              }
@@ -1212,7 +1242,10 @@ namespace M17N.Core
              {
                end -= grafted;
                if (start == end)
-                 return;
+                 {
+                   M17n.DebugPrint (" done\n");
+                   return;
+                 }
                rear_grafted = true;
              }
            if (interval != null)
@@ -1238,11 +1271,14 @@ namespace M17N.Core
            if (isRearSticky && ! Stack.IsEmpty)
              {
                enlarge (end - start);
+               M17n.DebugPrint (" done by enlarging this\n");
                return;
              }
            if (next != null && isFrontSticky && ! next.Stack.IsEmpty)
              {
+               M17n.DebugPrint (" next is {0}\n", next);
                next.enlarge (end - start);
+               M17n.DebugPrint (" done by enlarging next\n");
                return;
              }
            bool front_grafted = false, rear_grafted = false;
@@ -1252,14 +1288,20 @@ namespace M17N.Core
              {
                end -= grafted;
                if (start == end)
-                 return;
+                 {
+                   M17n.DebugPrint (" done\n");
+                   return;
+                 }
                rear_grafted = true;
              }
            if ((grafted = graft_forward (interval, start, end)) > 0)
              {
                start += grafted;
                if (start == end)
-                 return;
+                 {
+                   M17n.DebugPrint (" done\n");
+                   return;
+                 }
                front_grafted = true;
              }
            if (interval != null)
@@ -1345,7 +1387,7 @@ namespace M17N.Core
                Left.Delete (start, end);
                return;
              }
-           if (isSensitive || isFrontSensitive)
+           if (isSensitive)
              Stack.Clear ();
            Left.Delete (start, From);
            To -= From - start;
@@ -1362,7 +1404,7 @@ namespace M17N.Core
                Right.Delete (start, end);
                return;
              }
-           if (isSensitive || isRearSensitive)
+           if (isSensitive)
              Stack.Clear ();
            Right.Delete (To, end);
            end = To;
@@ -1403,13 +1445,8 @@ namespace M17N.Core
          {
            int len = end - start;
 
-           if (isSensitive
-               || (From < start && isRearSensitive)
-               || (end < To && isFrontSensitive))
-             {
-               M17n.DebugPrint ("clear this stack\n");
-               Stack.Clear ();
-             }
+           if (isSensitive)
+             Stack.Clear ();
            for (MInterval i = this; i != null; i = i.Parent)
              i.Length -= len;
          }
@@ -1665,7 +1702,7 @@ namespace M17N.Core
 
       public void DumpNested (bool force)
       {
-       DumpNested (Key.ToString () + ":", force);
+       DumpNested ("  " + Key.ToString () + ":", force);
       }
 
       public void DumpNested (string indent, bool force)