Author: atsushi
Date: 2006-01-15 08:01:30 -0500 (Sun, 15 Jan 2006)
New Revision: 55597

Modified:
   trunk/mcs/class/Commons.Xml.Relaxng/Commons.Xml.Relaxng.Derivative/ChangeLog
   
trunk/mcs/class/Commons.Xml.Relaxng/Commons.Xml.Relaxng.Derivative/RdpPatterns.cs
Log:
2006-01-15  Atsushi Enomoto <[EMAIL PROTECTED]>

        * RdpPatterns.cs : lazy evaluate Group branches. If left hand is
          notAllowed, the returned value is always NotAllowed, no need to
          compute another branch.



Modified: 
trunk/mcs/class/Commons.Xml.Relaxng/Commons.Xml.Relaxng.Derivative/ChangeLog
===================================================================
--- 
trunk/mcs/class/Commons.Xml.Relaxng/Commons.Xml.Relaxng.Derivative/ChangeLog    
    2006-01-15 11:17:18 UTC (rev 55596)
+++ 
trunk/mcs/class/Commons.Xml.Relaxng/Commons.Xml.Relaxng.Derivative/ChangeLog    
    2006-01-15 13:01:30 UTC (rev 55597)
@@ -1,3 +1,9 @@
+2006-01-15  Atsushi Enomoto <[EMAIL PROTECTED]>
+
+       * RdpPatterns.cs : lazy evaluate Group branches. If left hand is
+         notAllowed, the returned value is always NotAllowed, no need to
+         compute another branch.
+
 2006-01-13  Atsushi Enomoto <[EMAIL PROTECTED]>
 
        * RdpObjects.cs, RdpPatterns.cs : introduced "IsContextDependent"

Modified: 
trunk/mcs/class/Commons.Xml.Relaxng/Commons.Xml.Relaxng.Derivative/RdpPatterns.cs
===================================================================
--- 
trunk/mcs/class/Commons.Xml.Relaxng/Commons.Xml.Relaxng.Derivative/RdpPatterns.cs
   2006-01-15 11:17:18 UTC (rev 55596)
+++ 
trunk/mcs/class/Commons.Xml.Relaxng/Commons.Xml.Relaxng.Derivative/RdpPatterns.cs
   2006-01-15 13:01:30 UTC (rev 55597)
@@ -1236,35 +1236,43 @@
 
                public override RdpPattern TextDeriv (string s, XmlReader 
reader)
                {
-                       RdpPattern p = LValue.TextDeriv (s, reader).Group 
(RValue);
+                       RdpPattern p = LValue.TextDeriv (s, reader);
+                       p = (p.PatternType == RelaxngPatternType.NotAllowed) ?
+                               p : p.Group (RValue);
                        return LValue.Nullable ?
                                p.Choice (RValue.TextDeriv (s, reader)) : p;
                }
 
                internal override RdpPattern TextDeriv (string s, XmlReader 
reader, MemoizationStore memo)
                {
-                       RdpPattern p = memo.TextDeriv (LValue, s, reader).Group 
(RValue);
+                       RdpPattern p = memo.TextDeriv (LValue, s, reader);
+                       p = (p.PatternType == RelaxngPatternType.NotAllowed) ?
+                               p : p.Group (RValue);
                        return LValue.Nullable ?
                                p.Choice (memo.TextDeriv (RValue, s, reader)) : 
p;
                }
 
                internal override RdpPattern EmptyTextDeriv (MemoizationStore 
memo)
                {
-                       RdpPattern p = memo.EmptyTextDeriv (LValue).Group 
(RValue);
+                       RdpPattern p = memo.EmptyTextDeriv (LValue);
+                       p = p.PatternType == RelaxngPatternType.NotAllowed ?
+                               p : p.Group (RValue);
                        return LValue.Nullable ?
                                p.Choice (memo.EmptyTextDeriv (RValue)) : p;
                }
 
                internal override RdpPattern TextOnlyDeriv ()
                {
-                       return LValue.TextOnlyDeriv ().Group (
-                               RValue.TextOnlyDeriv ());
+                       RdpPattern p = LValue.TextOnlyDeriv ();
+                       return p.PatternType == RelaxngPatternType.NotAllowed ?
+                               p : p.Group (RValue.TextOnlyDeriv ());
                }
 
                internal override RdpPattern TextOnlyDeriv (MemoizationStore 
memo)
                {
-                       return memo.TextOnlyDeriv (LValue).Group (
-                               memo.TextOnlyDeriv (RValue));
+                       RdpPattern p = memo.TextOnlyDeriv (LValue);
+                       return p.PatternType == RelaxngPatternType.NotAllowed ?
+                               p : p.Group (memo.TextOnlyDeriv (RValue));
                }
 
                internal override RdpPattern MixedTextDeriv ()
@@ -1344,14 +1352,16 @@
                //  group (startTagCloseDeriv p1) (startTagCloseDeriv p2)
                public override RdpPattern StartTagCloseDeriv ()
                {
-                       return LValue.StartTagCloseDeriv ()
-                               .Group (RValue.StartTagCloseDeriv ());
+                       RdpPattern p = LValue.StartTagCloseDeriv ();
+                       return p.PatternType == RelaxngPatternType.NotAllowed ?
+                               p : p.Group (RValue.StartTagCloseDeriv ());
                }
 
                internal override RdpPattern StartTagCloseDeriv 
(MemoizationStore memo)
                {
-                       return memo.StartTagCloseDeriv (LValue)
-                               .Group (memo.StartTagCloseDeriv (RValue));
+                       RdpPattern p = memo.StartTagCloseDeriv (LValue);
+                       return p.PatternType == RelaxngPatternType.NotAllowed ?
+                               p : p.Group (memo.StartTagCloseDeriv (RValue));
                }
 
                public override RelaxngPatternType PatternType {
@@ -1459,17 +1469,23 @@
 
                public override RdpPattern TextDeriv (string s, XmlReader 
reader)
                {
-                       return Child.TextDeriv (s, reader).Group (this.Choice 
(RdpEmpty.Instance));
+                       RdpPattern p = Child.TextDeriv (s, reader);
+                       return p.PatternType == RelaxngPatternType.NotAllowed ?
+                               p : p.Group (this.Choice (RdpEmpty.Instance));
                }
 
                internal override RdpPattern TextDeriv (string s, XmlReader 
reader, MemoizationStore memo)
                {
-                       return memo.TextDeriv (Child, s, reader).Group 
(this.Choice (RdpEmpty.Instance));
+                       RdpPattern p = memo.TextDeriv (Child, s, reader);
+                       return p.PatternType == RelaxngPatternType.NotAllowed ?
+                               p : p.Group (this.Choice (RdpEmpty.Instance));
                }
 
                internal virtual RdpPattern EmptyTextDeriv (MemoizationStore 
memo)
                {
-                       return memo.EmptyTextDeriv (Child).Group (this.Choice 
(RdpEmpty.Instance));
+                       RdpPattern p = memo.EmptyTextDeriv (Child);
+                       return p.PatternType == RelaxngPatternType.NotAllowed ?
+                               p : p.Group (this.Choice (RdpEmpty.Instance));
                }
 
                internal override RdpPattern TextOnlyDeriv ()
@@ -1484,28 +1500,25 @@
 
                internal override RdpPattern MixedTextDeriv ()
                {
-                       return Child.MixedTextDeriv ().Group (
-                               this.Choice (RdpEmpty.Instance));
+                       RdpPattern p = Child.MixedTextDeriv ();
+                       return p.PatternType == RelaxngPatternType.NotAllowed ?
+                               p : p.Group (this.Choice (RdpEmpty.Instance));
                }
 
                internal override RdpPattern MixedTextDeriv (MemoizationStore 
memo)
                {
-                       return memo.MixedTextDeriv (Child).Group (
-                               this.Choice (RdpEmpty.Instance));
+                       RdpPattern p = memo.MixedTextDeriv (Child);
+                       return p.PatternType == RelaxngPatternType.NotAllowed ?
+                               p : p.Group (this.Choice (RdpEmpty.Instance));
                }
 
                // attDeriv cx (OneOrMore p) att =
                //  group (attDeriv cx p att) (choice (OneOrMore p) Empty)
                public override RdpPattern AttDeriv (string name, string ns, 
string value, XmlReader reader)
                {
-#if UseStatic
-                       return RdpUtil.Group (
-                               RdpUtil.AttDeriv (ctx, children, att),
-                               RdpUtil.Choice (RdpUtil.OneOrMore (children), 
RdpEmpty.Instance));
-#else
-                       return Child.AttDeriv (name, ns, value, reader)
-                               .Group (Choice (RdpEmpty.Instance));
-#endif
+                       RdpPattern p = Child.AttDeriv (name, ns, value, reader);
+                       return p.PatternType == RelaxngPatternType.NotAllowed ?
+                               p : p.Group (Choice (RdpEmpty.Instance));
                }
 
                // startTagOpenDeriv (OneOrMore p) qn =
@@ -1807,8 +1820,20 @@
                        // do nothing
                }
 
+               string cachedValue;
+               RdpPattern cachedPattern;
+
                public override RdpPattern TextDeriv (string s, XmlReader 
reader)
                {
+                       if (s == cachedValue && !IsContextDependent)
+                               return cachedPattern;
+                       cachedPattern = TextDerivCore (s, reader);
+                       cachedValue = s;
+                       return cachedPattern;
+               }
+
+               RdpPattern TextDerivCore (string s, XmlReader reader)
+               {
                        if (dt.IsTypeEqual (value, s, reader))
                                return RdpEmpty.Instance;
                        else

_______________________________________________
Mono-patches maillist  -  [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches

Reply via email to