Ejemplo n.º 1
0
        public AnyNode(AnyNode original)
            : base(original)
        {
            this.ValueProvider = original.ValueProvider;
            this.Operation     = original.Operation;
            this.Value         = original.Value;

            this.AnyToken    = original.AnyToken.CloneNode();
            this.NotAnyToken = original.NotAnyToken.CloneNode();
            this.EndAnyToken = original.EndAnyToken.CloneNode();

            this.AnyBlock    = (BlockNode)original.AnyBlock?.Let(a => a.CloneNode(true));
            this.NotAnyBlock = (BlockNode)original.NotAnyBlock?.Let(a => a.CloneNode(true));
        }
Ejemplo n.º 2
0
        public IfNode(IfNode original)
            : base(original)
        {
            this.ValueProvider = original.ValueProvider;
            this.Operation     = original.Operation;
            this.Value         = original.Value;

            this.IfToken    = original.IfToken.CloneNode();
            this.ElseToken  = original.ElseToken.CloneNode();
            this.EndIfToken = original.EndIfToken.CloneNode();

            this.IfBlock   = (BlockNode)original.IfBlock?.Let(a => a.CloneNode(true));
            this.ElseBlock = (BlockNode)original.ElseBlock?.Let(a => a.CloneNode(true));
        }
Ejemplo n.º 3
0
 public BlockNode(BlockNode original) : base(original)
 {
 }
        protected internal override void ReplaceBlock()
        {
            if (this.ElseToken.MatchNode == null)
            {
                this.NormalizeInterval(ref IfToken, ref EndIfToken, errorHintParent: IfToken.MatchNode);

                this.IfBlock = new BlockNode();
                this.IfBlock.MoveChilds(NodesBetween(IfToken, EndIfToken));

                IfToken.AscendantNode.ReplaceBy(this);
                EndIfToken.AscendantNode.Remove();
            }
            else
            {
                var elseToken = ElseToken;
                this.NormalizeInterval(ref IfToken, ref elseToken, errorHintParent: IfToken.MatchNode);
                this.NormalizeInterval(ref ElseToken, ref EndIfToken, errorHintParent: IfToken.MatchNode);

                if (elseToken.AscendantNode != ElseToken.AscendantNode)
                    throw new InvalidOperationException("Unbalanced tokens");

                this.IfBlock = new BlockNode();
                this.IfBlock.MoveChilds(NodesBetween(this.IfToken, this.ElseToken));

                this.ElseBlock = new BlockNode();
                this.ElseBlock.MoveChilds(NodesBetween(this.ElseToken, this.EndIfToken));

                this.IfToken.AscendantNode.ReplaceBy(this);
                this.ElseToken.AscendantNode.Remove();
                this.EndIfToken.AscendantNode.Remove();
            }
        }
        public IfNode(IfNode original)
            : base(original)
        {
            this.ValueProvider = original.ValueProvider;
            this.Operation = original.Operation;
            this.Value = original.Value;

            this.IfToken = original.IfToken.CloneNode();
            this.ElseToken = original.ElseToken.CloneNode();
            this.EndIfToken = original.EndIfToken.CloneNode();

            this.IfBlock = (BlockNode)original.IfBlock.Try(a => a.CloneNode(true));
            this.ElseBlock = (BlockNode)original.ElseBlock.Try(a => a.CloneNode(true));
        }
        protected internal override void ReplaceBlock()
        {
            if (this.NotAnyToken.MatchNode == null)
            {
                this.NormalizeInterval(ref AnyToken, ref EndAnyToken, errorHintParent: AnyToken.MatchNode);

                this.AnyBlock = new BlockNode();
                this.AnyBlock.MoveChilds(NodesBetween(AnyToken, EndAnyToken));

                this.AnyToken.AscendantNode.ReplaceBy(this);
                this.NotAnyToken.AscendantNode.Remove();
            }
            else
            {
                var notAnyToken = this.NotAnyToken;
                this.NormalizeInterval(ref AnyToken, ref notAnyToken, errorHintParent: AnyToken.MatchNode);
                this.NormalizeInterval(ref NotAnyToken, ref EndAnyToken, errorHintParent: AnyToken.MatchNode);

                if (notAnyToken.AscendantNode != NotAnyToken.AscendantNode)
                    throw new InvalidOperationException("Unbalanced tokens");

                this.AnyBlock = new BlockNode();
                this.AnyBlock.MoveChilds(NodesBetween(this.AnyToken, this.NotAnyToken));

                this.NotAnyBlock = new BlockNode();
                this.NotAnyBlock.MoveChilds(NodesBetween(this.NotAnyToken, this.EndAnyToken));

                this.AnyToken.AscendantNode.ReplaceBy(this);
                this.NotAnyToken.AscendantNode.Remove();
                this.EndAnyToken.AscendantNode.Remove();
            }
        }
        public AnyNode(AnyNode original)
            : base(original)
        {
            this.ValueProvider = original.ValueProvider;
            this.Operation = original.Operation;
            this.Value = original.Value;

            this.AnyToken = original.AnyToken.CloneNode();
            this.NotAnyToken = original.NotAnyToken.CloneNode();
            this.EndAnyToken = original.EndAnyToken.CloneNode();

            this.AnyBlock = (BlockNode)original.AnyBlock.Try(a => a.CloneNode(true));
            this.NotAnyBlock = (BlockNode)original.NotAnyBlock.Try(a => a.CloneNode(true));
        }
        protected internal override void ReplaceBlock()
        {
            this.NormalizeInterval(ref ForeachToken, ref EndForeachToken, errorHintParent: ForeachToken.MatchNode);

            this.ForeachBlock = new BlockNode();
            this.ForeachBlock.MoveChilds(NodesBetween(ForeachToken, EndForeachToken));

            ForeachToken.AscendantNode.ReplaceBy(this);
            EndForeachToken.AscendantNode.Remove();
        }
 public ForeachNode(ForeachNode original)
     : base(original)
 {
     this.ValueProvider = original.ValueProvider;
     this.ForeachToken = original.ForeachToken.CloneNode();
     this.EndForeachToken = original.EndForeachToken.CloneNode();
     this.ForeachBlock = (BlockNode)original.ForeachBlock.Try(a => a.CloneNode(true));
 }
 public BlockNode(BlockNode original) : base(original) { }