protected override void Visit(EndElementNode node)
 {
     if (NameUtility.IsMatch("include", "http://www.w3.org/2001/XInclude", node.Name, node.Namespace, base.Context.Namespaces))
     {
         int num;
         if ((base.FrameData.Mode != Mode.FailedInclude) && (base.FrameData.Mode != Mode.SuccessfulInclude))
         {
             throw new CompilerException("Unexpected </include> element");
         }
         Frame frameData = base.FrameData;
         frameData.RedundantDepth = (num = frameData.RedundantDepth) - 1;
         if (num == 0)
         {
             this.EndInclude();
         }
     }
     else if (NameUtility.IsMatch("fallback", "http://www.w3.org/2001/XInclude", node.Name, node.Namespace, base.Context.Namespaces))
     {
         int num2;
         if ((base.FrameData.Mode != Mode.NormalContent) && (base.FrameData.Mode != Mode.IgnoringFallback))
         {
             throw new CompilerException("Unexpected </fallback> element");
         }
         Frame local2 = base.FrameData;
         local2.RedundantDepth = (num2 = local2.RedundantDepth) - 1;
         if (num2 == 0)
         {
             this.EndFallback();
         }
     }
     else
     {
         base.Visit(node);
     }
 }
        protected override void Visit(SpecialNode node)
        {
            bool flag = false;

            if ((NameUtility.IsMatch("else", base.Context.Namespaces, node.Element.Name, node.Element.Namespace) && node.Element.IsEmptyElement) && (this._frame.TestParentNodes != null))
            {
                flag = true;
            }
            if (flag)
            {
                SpecialNode item = new SpecialNode(node.Element);
                this._frame.TestParentNodes.Add(item);
                this._frame.Nodes = item.Body;
            }
            else
            {
                SpecialNode node3 = new SpecialNode(node.Element);
                this.Nodes.Add(node3);
                IList <Node> nodes = this._frame.Nodes;
                this.PushFrame();
                this._frame.Nodes = node3.Body;
                if (NameUtility.IsMatch("if", base.Context.Namespaces, node.Element.Name, node.Element.Namespace) || NameUtility.IsMatch("test", base.Context.Namespaces, node.Element.Name, node.Element.Namespace))
                {
                    this._frame.TestParentNodes = nodes;
                }
                base.Accept(node.Body);
                this.PopFrame();
            }
        }
Exemple #3
0
 protected override void Visit(EndElementNode node)
 {
     if (NameUtility.IsMatch("include", Constants.XIncludeNamespace, node.Name, node.Namespace, Context.Namespaces))
     {
         if (FrameData.Mode != Mode.FailedInclude &&
             FrameData.Mode != Mode.SuccessfulInclude)
         {
             throw new CompilerException("Unexpected </include> element");
         }
         if (FrameData.RedundantDepth-- == 0)
         {
             EndInclude();
         }
         return;
     }
     if (NameUtility.IsMatch("fallback", Constants.XIncludeNamespace, node.Name, node.Namespace, Context.Namespaces))
     {
         if (FrameData.Mode != Mode.NormalContent &&
             FrameData.Mode != Mode.IgnoringFallback)
         {
             throw new CompilerException("Unexpected </fallback> element");
         }
         if (FrameData.RedundantDepth-- == 0)
         {
             EndFallback();
         }
         return;
     }
     base.Visit(node);
 }
 protected override void Visit(ElementNode node)
 {
     if (NameUtility.IsMatch("include", "http://www.w3.org/2001/XInclude", node.Name, node.Namespace, base.Context.Namespaces))
     {
         if ((base.FrameData.Mode == Mode.SuccessfulInclude) || (base.FrameData.Mode == Mode.FailedInclude))
         {
             if (!node.IsEmptyElement)
             {
                 Frame frameData = base.FrameData;
                 frameData.RedundantDepth++;
             }
         }
         else
         {
             AttributeNode node2 = node.Attributes.FirstOrDefault <AttributeNode>(a => a.Name == "href");
             AttributeNode node3 = node.Attributes.FirstOrDefault <AttributeNode>(a => a.Name == "parse");
             this.BeginInclude(node2.Value, (node3 == null) ? "xml" : node3.Value);
             if (node.IsEmptyElement)
             {
                 this.EndInclude();
             }
         }
     }
     else if (NameUtility.IsMatch("fallback", "http://www.w3.org/2001/XInclude", node.Name, node.Namespace, base.Context.Namespaces))
     {
         if (base.FrameData.Mode == Mode.IgnoringFallback)
         {
             if (!node.IsEmptyElement)
             {
                 Frame local2 = base.FrameData;
                 local2.RedundantDepth++;
             }
         }
         else
         {
             this.BeginFallback();
             if (node.IsEmptyElement)
             {
                 this.EndFallback();
             }
         }
     }
     else
     {
         base.Visit(node);
     }
 }
Exemple #5
0
        protected override void Visit(ElementNode node)
        {
            if (NameUtility.IsMatch("include", Constants.XIncludeNamespace, node.Name, node.Namespace, Context.Namespaces))
            {
                if (FrameData.Mode == Mode.SuccessfulInclude ||
                    FrameData.Mode == Mode.FailedInclude)
                {
                    if (!node.IsEmptyElement)
                    {
                        FrameData.RedundantDepth++;
                    }
                    return;
                }

                var href  = node.Attributes.FirstOrDefault(a => a.Name == "href");
                var parse = node.Attributes.FirstOrDefault(a => a.Name == "parse");
                BeginInclude(href.Value, parse == null ? "xml" : parse.Value);
                if (node.IsEmptyElement)
                {
                    EndInclude();
                }
                return;
            }

            if (NameUtility.IsMatch("fallback", Constants.XIncludeNamespace, node.Name, node.Namespace, Context.Namespaces))
            {
                if (FrameData.Mode == Mode.IgnoringFallback)
                {
                    if (!node.IsEmptyElement)
                    {
                        FrameData.RedundantDepth++;
                    }
                    return;
                }

                BeginFallback();
                if (node.IsEmptyElement)
                {
                    EndFallback();
                }
                return;
            }

            base.Visit(node);
        }
Exemple #6
0
        protected override void Visit(SpecialNode node)
        {
            bool detachFromParent = false;

            if (NameUtility.IsMatch("else", Context.Namespaces, node.Element.Name, node.Element.Namespace) &&
                node.Element.IsEmptyElement &&
                _frame.TestParentNodes != null)
            {
                detachFromParent = true;
            }

            if (detachFromParent)
            {
                var reconstructed = new SpecialNode(node.Element);
                _frame.TestParentNodes.Add(reconstructed);
                _frame.Nodes = reconstructed.Body;
            }
            else
            {
                var reconstructed = new SpecialNode(node.Element);
                Nodes.Add(reconstructed);

                var parentNodes = _frame.Nodes;

                PushFrame();

                _frame.Nodes = reconstructed.Body;
                if (NameUtility.IsMatch("if", Context.Namespaces, node.Element.Name, node.Element.Namespace) ||
                    NameUtility.IsMatch("test", Context.Namespaces, node.Element.Name, node.Element.Namespace))
                {
                    _frame.TestParentNodes = parentNodes;
                }

                Accept(node.Body);

                PopFrame();
            }
        }