示例#1
0
        public void TestFindActiveIdentifiers()
        {
            // Build up a tree with OR node as root, child a (OR node) for value 0, child b (value node) for value 1.
            // Create the nodes.
            IParameterTreeNode a = new OrNode <int>("a", new CategoricalDomain <int>(new List <int> {
                2, 5
            }));
            IParameterTreeNode b = new ValueNode <int>("b", new IntegerDomain());
            var rootDecision     = new OrNode <int>("or", new CategoricalDomain <int>(new List <int> {
                0, 1
            }));

            // Create connections.
            rootDecision.AddChild(0, a);
            rootDecision.AddChild(1, b);
            var parameterTree = new ParameterTree(rootDecision);

            // Set value for roort node s.t. only node a should be active.
            var values = new Dictionary <string, IAllele>(3)
            {
                { "a", new Allele <int>(2) },
                { "b", new Allele <int>(7) },
                { "or", new Allele <int>(0) },
            };

            var activeIdentifiers         = parameterTree.FindActiveIdentifiers(values.ToImmutableDictionary()).ToList();
            var expectedActiveIdentifiers = new List <string> {
                "or", "a"
            };

            Assert.True(
                TestUtils.SetsAreEquivalent(activeIdentifiers, expectedActiveIdentifiers),
                $"Active identifiers should be {TestUtils.PrintList(expectedActiveIdentifiers)}, but are {TestUtils.PrintList(activeIdentifiers)}.");
        }
        public void ResetSimulationTest()
        {
            var inputNode1 = new InputNode("in1", new State(false));
            var inputNode2 = new InputNode("in2", new State(true));
            var orNode     = new OrNode("or");
            var outputNode = new OutputNode("out");

            var nodeConnections = new List <NodeConnection>
            {
                new NodeConnection(
                    new List <NodeBase> {
                    inputNode1, inputNode2
                },
                    orNode),
                new NodeConnection(orNode, outputNode)
            };

            var inputNodes = new List <InputNode>
            {
                inputNode1,
                inputNode2
            };

            var simulation = new NodeSimulation(nodeConnections);

            simulation.RunSimulation();
            simulation.ResetSimulation();

            var output = simulation.GetOutputState();

            Assert.Null(output["out"]);
        }
        public void SetInvalidAmountInputsTest()
        {
            var inputNode1 = new InputNode("in1");
            var inputNode2 = new InputNode("in2");
            var orNode     = new OrNode("or");
            var outputNode = new OutputNode("out");

            var nodeConnections = new List <NodeConnection>
            {
                new NodeConnection(
                    new List <NodeBase> {
                    inputNode1, inputNode2
                },
                    orNode),
                new NodeConnection(orNode, outputNode)
            };

            var inputNodes = new List <InputNode>
            {
                inputNode1,
                inputNode2
            };

            var simulation = new NodeSimulation(nodeConnections);

            var inputValues = new Dictionary <string, State>
            {
                { inputNode1.NodeId, new State(true) },
                { inputNode2.NodeId, new State(false) },
                { orNode.NodeId, new State(false) }
            };

            Assert.Throws <ArgumentException>(() => simulation.SetInputs(inputValues));
        }
        public void CreateSimulationTest()
        {
            var inputNode1 = new InputNode("in1", new State(false));
            var inputNode2 = new InputNode("in2", new State(true));
            var orNode     = new OrNode("or");
            var outputNode = new OutputNode("out");

            var nodeConnections = new List <NodeConnection>
            {
                new NodeConnection(
                    new List <NodeBase> {
                    inputNode1, inputNode2
                },
                    orNode),
                new NodeConnection(orNode, outputNode)
            };

            var inputNodes = new List <InputNode>
            {
                inputNode1,
                inputNode2
            };

            var simulation = new NodeSimulation(nodeConnections);

            // TODO: Is this the same as CollectionAssert?
            Assert.Equal(nodeConnections, simulation.NodeConnections);
        }
示例#5
0
        public override BaseNode VisitFilterExpression(QueryFilteringParser.FilterExpressionContext context)
        {
            BaseNode resultNode = context.children[0].Accept(this);

            for (int i = 1; i < context.children.Count; i += 2)
            {
                var left  = resultNode;
                var right = context.children[i + 1].Accept(this);

                var aggregateNode = (ITerminalNode)context.children[i];

                switch (aggregateNode.Symbol.Type)
                {
                case QueryFilteringLexer.AND:
                    resultNode = new AndNode(left, right);
                    continue;

                case QueryFilteringLexer.OR:
                    resultNode = new OrNode(left, right);
                    continue;

                default:
                    throw new ParseRuleException(
                              nameof(FilterExpressionVisitor),
                              $"неизвестный тип предиката '{aggregateNode.Symbol.Type}'");
                }
            }

            return(resultNode);
        }
示例#6
0
        /// <summary>
        /// Takes a list of tokenized input and create the corresponding expression tree.
        /// </summary>
        /// <param name="tokenList">
        /// Tokenized list of the input string.
        /// </param>
        private Node ConstructExpressionTree(List <Token> tokenList)
        {
            bool         notFlag  = false;
            Queue <Node> andQueue = new Queue <Node>();
            Queue <Node> orQueue  = new Queue <Node>();

            for (int i = 0; i < tokenList.Count; i++)
            {
                Token     token = tokenList[i];
                TokenKind kind  = token.Kind;
                if (kind == TokenKind.Identifier)
                {
                    Node idNode = new OperandNode(token.Text);
                    if (notFlag)    // identifier preceded by NOT
                    {
                        Node notNode = new NotNode();
                        notNode.Operand1 = idNode;
                        notFlag          = false;
                        andQueue.Enqueue(notNode);
                    }
                    else
                    {
                        andQueue.Enqueue(idNode);
                    }
                }
                else if (kind == TokenKind.Not)
                {
                    notFlag = true;
                }
                else if (kind == TokenKind.And)
                {
                    // do nothing
                }
                else if (kind == TokenKind.Or)
                {
                    // Dequeue all nodes from AND queue,
                    // create the AND tree, then add to the OR queue.
                    Node andCurrent = andQueue.Dequeue();
                    while (andQueue.Count > 0)
                    {
                        Node andNode = new AndNode(andCurrent);
                        andNode.Operand1 = andQueue.Dequeue();
                        andCurrent       = andNode;
                    }
                    orQueue.Enqueue(andCurrent);
                }
            }

            // Dequeue all nodes from OR queue,
            // create the OR tree (final expression tree)
            Node orCurrent = orQueue.Dequeue();

            while (orQueue.Count > 0)
            {
                Node orNode = new OrNode(orCurrent);
                orNode.Operand1 = orQueue.Dequeue();
                orCurrent       = orNode;
            }
            return(orCurrent);
        }
        public void Should_parse_or_expression()
        {
            OrNode or = (OrNode)Parse("1~or~2");

            Assert.Equal(1, Convert.ToInt32(((NumberNode)or.First).Value));
            Assert.Equal(2, Convert.ToInt32(((NumberNode)or.Second).Value));
        }
示例#8
0
 public Func <IQuery <T>, ValueTask <IQuery <T> > > Visit(OrNode node, QueryExecutionContext <T> argument)
 {
     return(result => argument.Item.AnyAsync(
                (q) => node.Left.Accept(this, argument)(q),
                (q) => node.Right.Accept(this, argument)(q)
                ));
 }
        protected virtual QueryNode VisitOr(OrNode node, AzureQueryOptimizerState state)
        {
            QueryNode queryNode1    = this.Visit(node.LeftNode, state);
            QueryNode queryNode2    = this.Visit(node.RightNode, state);
            bool?     booleanValue1 = this.GetBooleanValue(queryNode1);
            bool?     booleanValue2 = this.GetBooleanValue(queryNode2);

            if (!booleanValue1.HasValue && !booleanValue2.HasValue)
            {
                return((QueryNode) new OrNode(queryNode1, queryNode2));
            }
            if (booleanValue1.HasValue && booleanValue2.HasValue)
            {
                if (!booleanValue1.Value && !booleanValue2.Value)
                {
                    return((QueryNode) new MatchNoneNode());
                }
                return((QueryNode) new MatchAllNode());
            }
            if (booleanValue1.HasValue)
            {
                return(queryNode2);
            }
            return(queryNode1);
        }
 private Value Or(OrNode exp)
 {
     try
     {
         Constant  left  = Eval(exp.Left).GetRValue();
         Constant  right = Eval(exp.Right).GetRValue();
         BoolValue l     = (BoolValue)Convert(left, Constant.Type.Bool);
         BoolValue r     = (BoolValue)Convert(right, Constant.Type.Bool);
         return(BoolValue.OpOr(l, r));
     }
     catch (TypeConversionError exc)
     {
         throw new ModelInterpreterException($"Операция \"ИЛИ\" не определена для типов \"{exc.Src}\" и \"{exc.Dst}\"")
               {
                   Line     = exp.Line,
                   Position = exp.Position
               };
     }
     catch (Exception exc)
     {
         throw new ModelInterpreterException(exc.Message)
               {
                   Line     = exp.Line,
                   Position = exp.Position
               };
     }
 }
示例#11
0
        public void GetFilteredGenesHandlesOrNodesCorrectly()
        {
            // Build up a tree with OR node as root, child a (OR node) for value 0, child b (value node) for value 1.
            // Create the nodes.
            IParameterTreeNode a = new OrNode <int>("a", new CategoricalDomain <int>(new List <int> {
                2, 5
            }));
            IParameterTreeNode b            = new ValueNode <int>("b", new IntegerDomain());
            OrNode <int>       rootDecision = new OrNode <int>("or", new CategoricalDomain <int>(new List <int> {
                0, 1
            }));

            // Create connections.
            rootDecision.AddChild(0, a);
            rootDecision.AddChild(1, b);

            var parameterTree = new ParameterTree(rootDecision);

            this._genome.SetGene("a", new Allele <int>(2));
            this._genome.SetGene("b", new Allele <int>(7));
            this._genome.SetGene("or", new Allele <int>(0));

            var filteredGenes         = this._genome.GetFilteredGenes(parameterTree);
            var expectedFilteredGenes = new List <string> {
                "or", "a"
            };

            Assert.True(
                TestUtils.SetsAreEquivalent(filteredGenes.Keys, expectedFilteredGenes),
                $"Filtered genes should be {TestUtils.PrintList(expectedFilteredGenes)}, but are {TestUtils.PrintList(filteredGenes.Keys)}.");
        }
        public OrNode Or()
        {
            OrNode orNode = new OrNode();

            Match(TokenType.OR);
            return(orNode);
        }
        public void Visit(OrNode node)
        {
            var right = Nodes.Pop();
            var left  = Nodes.Pop();

            Nodes.Push(new OrNode(left, right));
        }
        protected virtual BaseQuery HandleOr(OrNode node, ElasticSearchQueryMapperState state)
        {
            //TODO: the code below specifically handles IsNullOrEmpty method, seems like a lot to handle one case... is there a better place for it?
            //Lucene provider doesn't have this code, but Solr provider does
            if (node.LeftNode.NodeType == QueryNodeType.Equal && node.RightNode.NodeType == QueryNodeType.Equal)
            {
                var leftNode  = (EqualNode)node.LeftNode;
                var rightNode = (EqualNode)node.RightNode;
                if (leftNode.RightNode.NodeType == QueryNodeType.Constant && rightNode.RightNode.NodeType == QueryNodeType.Constant)
                {
                    var leftNodeValue  = ((ConstantNode)leftNode.RightNode).Value;
                    var rightNodeValue = ((ConstantNode)rightNode.RightNode).Value;
                    if ((string)leftNodeValue == string.Empty && rightNodeValue == null)
                    {
                        var fieldName = ((FieldNode)leftNode.LeftNode).FieldKey;
                        //TODO: this query works for 99% of items, however if a field contains a stopword and only a stopword, then it's treated as "missing" by ES
                        //For example, say you have an item whose "Title" field contains just the word "To" (which is a stopword), if you try to search for all items
                        //without a value in the "Title" field (i.e. the field is missing), ES will still return the item whose "Title" field contains just the word "To".
                        //There's likely a better query to use... or maybe not, maybe it can only be done with analyzers. who could say?
                        return(Query.Filtered(fq => fq.Filter(f => f.Missing(fieldName))));
                    }
                }
            }

            var query1 = Handle(node.LeftNode, state);
            var query2 = Handle(node.RightNode, state);

            if (query1)
            {
                return(query1);
            }

            return(query1 | query2);
        }
示例#15
0
        /// <summary>
        /// Builds the following parameter tree:
        /// - AND node as root
        /// - 1st child of AND node: OR node with string either a or b (default: "a")
        /// - 2nd child of AND node: value node with integer between 1 and 5 (default: 1)
        /// - OR node, a branch: value node with integer (default: 42).
        /// - OR node, b branch: value node with double between 0.1 and 0.8 (default: 0.2).
        /// </summary>
        /// <param name="includeDefaultValues">Indicates whether to add default values to the domains.</param>
        /// <returns>The build parameter tree.</returns>
        private static ParameterTree BuildParameterTree(bool includeDefaultValues = false)
        {
            // Create all parameter tree nodes.
            var             rootNode       = new AndNode();
            OrNode <string> decideAOrBNode = new OrNode <string>(
                DecisionParameter,
                new CategoricalDomain <string>(new List <string> {
                "a", "b"
            }, includeDefaultValues ? new Allele <string>("a") : (Allele <string>?)null));

            IParameterNode integerParamNode = new ValueNode <int>(
                GenomeBuilderTest.DiscreteParameter,
                new IntegerDomain(defaultValue: includeDefaultValues ? new Allele <int>(42) : (Allele <int>?)null));
            IParameterNode continuousParamNode = new ValueNode <double>(
                GenomeBuilderTest.ContinuousParameter,
                new ContinuousDomain(0.1, 0.8, includeDefaultValues ? new Allele <double>(0.2) : (Allele <double>?)null));

            IParameterNode smallIntegerParamNode = new ValueNode <int>(
                GenomeBuilderTest.SmallValueParameter,
                new IntegerDomain(1, 5, includeDefaultValues ? new Allele <int>(1) : (Allele <int>?)null));

            // Connect them.
            decideAOrBNode.AddChild("a", integerParamNode);
            decideAOrBNode.AddChild("b", continuousParamNode);
            rootNode.AddChild(decideAOrBNode);
            rootNode.AddChild(smallIntegerParamNode);

            // Return tree.
            return(new ParameterTree(rootNode));
        }
示例#16
0
        /// <summary>
        /// Converts this node to an <see cref="OrNode{T}"/>.
        /// </summary>
        /// <typeparam name="T">The type of values the represented parameter can take.</typeparam>
        /// <returns>The converted <see cref="OrNode{T}"/>.</returns>
        /// <exception cref="XmlException">Thrown if the object was read from XML in such a way that it
        /// does not represent a valid <see cref="IParameterTreeNode"/> object.</exception>
        protected override IParameterTreeNode ConvertToParameterTreeNode<T>()
        {
            // Cast domain to correct type.
            CategoricalDomain<T> categoricalDomain =
                this.domain.ConvertToParameterTreeDomain() as CategoricalDomain<T>;
            if (categoricalDomain == null)
            {
                throw new XmlException(
                    $"Domain of OR node '{this.id}' was not of type {typeof(CategoricalDomain<T>)} as expected.");
            }

            // Create OR node.
            var node = new OrNode<T>(this.id, categoricalDomain);

            // Add children:
            foreach (var choice in this.choice)
            {
                // Check activator is of correct type.
                if (!(choice.Item is T))
                {
                    throw new XmlException(
                        $"OR node '{this.id}' had a choice of type {choice.Item.GetType()} instead of {typeof(T)}.");
                }

                // Add child.
                node.AddChild((T)choice.Item, choice.child.ConvertToParameterTreeNode());
            }

            return node;
        }
示例#17
0
        public void GenerateCode(OrNode node, ICIL_CodeGenerator codeGenerator)
        {
            node.Holder = codeGenerator.DefineVariable();

            codeGenerator.AddLocalVariable(
                new CIL_LocalVariable((Variable)node.Holder));

            GenerateCode(node.OpNode1, codeGenerator);

            codeGenerator.AddInstruction(
                new Assign((Variable)node.Holder, node.OpNode1.Holder));

            var label = codeGenerator.DefineLabel();

            codeGenerator.AddInstruction(
                new ConditionalJump((Variable)node.Holder, true, label));

            GenerateCode(node.OpNode2, codeGenerator);

            codeGenerator.AddInstruction(
                new Assign((Variable)node.Holder, node.OpNode2.Holder));

            codeGenerator.AddInstruction(
                new Label(label));
        }
        private string BuildFilter(OrNode orNode)
        {
            string tempFilter = "";

            foreach (var Node in orNode.Nodes)
            {
                if (tempFilter.Trim().Length > 0)
                {
                    tempFilter += " OR ";
                }
                ;
                if (Node.GetType() == typeof(ParameterNode))
                {
                    tempFilter += BuildFilter((ParameterNode)Node);
                }
                ;
                if (Node.GetType() == typeof(AndNode))
                {
                    tempFilter += BuildFilter((AndNode)Node);
                }
                ;
                if (Node.GetType() == typeof(OrNode))
                {
                    tempFilter += BuildFilter((OrNode)Node);
                }
                ;
            }
            return($"({tempFilter})");
        }
示例#19
0
        public void OrNode_should_accept_visitor()
        {
            visitor.Setup(v => v.StartVisit(It.IsAny <ILogicalNode>())).Verifiable();
            visitor.Setup(v => v.EndVisit()).Verifiable();

            Mock <IFilterNode> first = new Mock <IFilterNode>();

            first.Setup(f => f.Accept(It.IsAny <IFilterNodeVisitor>())).Verifiable();

            Mock <IFilterNode> second = new Mock <IFilterNode>();

            second.Setup(f => f.Accept(It.IsAny <IFilterNodeVisitor>())).Verifiable();

            OrNode orNode = new OrNode
            {
                First  = first.Object,
                Second = second.Object
            };

            orNode.Accept(visitor.Object);

            visitor.VerifyAll();
            first.Verify();
            second.Verify();
        }
        public void Should_parse_complex_nested_expression()
        {
            OrNode or = (OrNode)Parse("(age~lt~20~and~startswith(name,'j'))~or~(endswith(name,'s')~and~number~gt~20)");

            Assert.IsType(typeof(AndNode), or.First);
            Assert.IsType(typeof(AndNode), or.Second);
        }
示例#21
0
        public object Visit(OrNode node, object value)
        {
            foreach (var child in node.Children)
            {
                child.Accept(this, null);
            }

            return(this);
        }
示例#22
0
        void PropagateNotToLeaves(ref IQueryNode rootNode)
        {
            if (rootNode.leaf || !(rootNode is CombinedNode cn))
            {
                return;
            }

            if (rootNode.type != QueryNodeType.Not)
            {
                return;
            }

            var parent  = rootNode.parent;
            var oldNode = rootNode.children[0];

            if (!(oldNode is CombinedNode oldCombinedNode) || (oldCombinedNode.type != QueryNodeType.And && oldCombinedNode.type != QueryNodeType.Or))
            {
                return;
            }

            CombinedNode newCombinedNode;

            if (oldNode.type == QueryNodeType.And)
            {
                newCombinedNode = new OrNode();
            }
            else
            {
                newCombinedNode = new AndNode();
            }

            cn.RemoveNode(oldNode);

            foreach (var child in oldNode.children)
            {
                var propagatedNotNode = new NotNode();
                propagatedNotNode.AddNode(child);
                newCombinedNode.AddNode(propagatedNotNode);
            }
            oldCombinedNode.Clear();

            // If the old not is the root of the evaluationGraph, then the new combined node
            // becomes the new root.
            if (parent == null)
            {
                this.root = newCombinedNode;
            }
            else
            {
                // In order to not change the parent's enumeration, swap directly the old
                // children with the new one
                SwapChild(parent, rootNode, newCombinedNode);
            }
            // Set the current tree root to the new combined node.
            rootNode = newCombinedNode;
        }
示例#23
0
        private Node Expression()
        {
            var node = Xor();

            while (_lexer.TryReadChar('|'))
            {
                node = new OrNode(node, Xor());
            }
            return(node);
        }
        protected QueryBase VisitOr(OrNode node, ElasticQueryMapperState state)
        {
            // TODO: NullOrEmpty check and maybe more
            var query1 = Visit(node.LeftNode, state);
            var query2 = Visit(node.RightNode, state);

            // TODO: This is the same as Union - not sure if that is correct
            // TODO: Need to check if this is correct, but it should be: https://www.elastic.co/guide/en/elasticsearch/guide/current/bool-query.html
            return(query1 || query2);
        }
        // Token: 0x060000C9 RID: 201 RVA: 0x000053E4 File Offset: 0x000035E4
        public TreeNode CreateSubtree()
        {
            OrNode orNode = new OrNode();

            foreach (ClassificationDecoding classificationDecoding in this.decodings)
            {
                orNode.AddNode(classificationDecoding.CreateSubtree());
            }
            return(orNode);
        }
        /// <summary>
        /// Creates a parameter tree which root is an OR node "decision". If that is true, a value node "a" is
        /// evaluated, otherwise a value node "b".
        /// </summary>
        /// <returns>The created parameter tree.</returns>
        private static ParameterTree CreateParameterTree()
        {
            var decisionNode =
                new OrNode <bool>("decision", new CategoricalDomain <bool>(new List <bool> {
                true, false
            }));

            decisionNode.AddChild(true, new ValueNode <double>("a", new ContinuousDomain()));
            decisionNode.AddChild(false, new ValueNode <double>("b", new ContinuousDomain()));
            return(new ParameterTree(decisionNode));
        }
示例#27
0
        private ExpressionNode ParseExpression()
        {
            var lhs = ParseJoin();

            while (_reader.Peek() is Or)
            {
                lhs = new OrNode(lhs, ParseJoin());
            }

            return(lhs);
        }
示例#28
0
        private Node ConstructExpressionTree(List <Token> tokenList)
        {
            bool         flag   = false;
            Queue <Node> queue  = new Queue <Node>();
            Queue <Node> queue2 = new Queue <Node>();

            for (int i = 0; i < tokenList.Count; i++)
            {
                Token     token = tokenList[i];
                TokenKind kind  = token.Kind;
                if (kind == TokenKind.Identifier)
                {
                    Node item = new OperandNode(token.Text);
                    if (flag)
                    {
                        Node node2 = new NotNode {
                            Operand1 = item
                        };
                        flag = false;
                        queue.Enqueue(node2);
                    }
                    else
                    {
                        queue.Enqueue(item);
                    }
                }
                else if (kind == TokenKind.Not)
                {
                    flag = true;
                }
                else if ((kind != TokenKind.And) && (kind == TokenKind.Or))
                {
                    Node node3 = queue.Dequeue();
                    while (queue.Count > 0)
                    {
                        node3 = new AndNode(node3)
                        {
                            Operand1 = queue.Dequeue()
                        };
                    }
                    queue2.Enqueue(node3);
                }
            }
            Node n = queue2.Dequeue();

            while (queue2.Count > 0)
            {
                n = new OrNode(n)
                {
                    Operand1 = queue2.Dequeue()
                };
            }
            return(n);
        }
示例#29
0
        public void Or_VariousPairs_MatchesString(string in0, string in1, string shouldMatch)
        {
            var node = new OrNode();

            node.Inputs.Inputs.ElementAt(0).ConnectedNode = new FakeNodeOutput(in0);
            node.Inputs.Inputs.ElementAt(1).ConnectedNode = new FakeNodeOutput(in1);

            string nodeVal = node.CachedOutput.Expression;

            Assert.That(nodeVal, Is.Not.Null);
            Assert.That(shouldMatch, Does.Match(nodeVal));
        }
 private void Initialize()
 {
     _prototypes["AND"]   = new AndNode();
     _prototypes["NOT"]   = new NotNode();
     _prototypes["NAND"]  = new NotAndNode();
     _prototypes["NOR"]   = new NotOrNode();
     _prototypes["OR"]    = new OrNode();
     _prototypes["PROBE"] = new OutputNode();
     _prototypes["INPUT"] = new InputNode();
     _prototypes["XOR"]   = new XorNode();
     _prototypes["NODE"]  = new Node();
 }
        public void Should_return_composite_descriptor_for_or_node()
        {
            OrNode orNode = new OrNode()
            {
                First = DateTimeComparison(),
                Second = StringFunction()
            };

            orNode.Accept(visitor);

            CompositeFilterDescriptor descriptor = (CompositeFilterDescriptor)visitor.Result;
            Assert.Equal(FilterCompositionLogicalOperator.Or, descriptor.LogicalOperator);
            Assert.Equal(FilterOperator.IsEqualTo, ((FilterDescriptor)descriptor.FilterDescriptors[0]).Operator);
            Assert.Equal(FilterOperator.StartsWith, ((FilterDescriptor)descriptor.FilterDescriptors[1]).Operator);
        }
示例#32
0
    // throws RecognitionException [1]
    // $ANTLR end "language"
    // $ANTLR start "expr_or"
    // C:\\Users\\Danaice\\Desktop\\lastversion\\Dany_gramatica tiger ANTLR oficial\\tiger_grammar.g:93:1: expr_or returns [TigerNode or] : exp1= expr_and ( OR exp2= expr_and )* ;
    public TigerNode expr_or()
    {
        TigerNode or = null;

        IToken OR2 = null;
        TigerNode exp1 = null;

        TigerNode exp2 = null;

        try
        {
            // C:\\Users\\Danaice\\Desktop\\lastversion\\Dany_gramatica tiger ANTLR oficial\\tiger_grammar.g:93:31: (exp1= expr_and ( OR exp2= expr_and )* )
            // C:\\Users\\Danaice\\Desktop\\lastversion\\Dany_gramatica tiger ANTLR oficial\\tiger_grammar.g:93:33: exp1= expr_and ( OR exp2= expr_and )*
            {
                PushFollow(FOLLOW_expr_and_in_expr_or542);
                exp1 = expr_and();
                state.followingStackPointer--;
                if (state.failed) return or;
                if ( (state.backtracking==0) )
                {
                  or =  exp1;
                }
                // C:\\Users\\Danaice\\Desktop\\lastversion\\Dany_gramatica tiger ANTLR oficial\\tiger_grammar.g:94:25: ( OR exp2= expr_and )*
                do
                {
                    int alt2 = 2;
                    int LA2_0 = input.LA(1);

                    if ( (LA2_0 == OR) )
                    {
                        alt2 = 1;
                    }

                    switch (alt2)
                    {
                        case 1 :
                            // C:\\Users\\Danaice\\Desktop\\lastversion\\Dany_gramatica tiger ANTLR oficial\\tiger_grammar.g:94:26: OR exp2= expr_and
                            {
                                OR2=(IToken)Match(input,OR,FOLLOW_OR_in_expr_or571); if (state.failed) return or;
                                PushFollow(FOLLOW_expr_and_in_expr_or576);
                                exp2 = expr_and();
                                state.followingStackPointer--;
                                if (state.failed) return or;
                                if ( (state.backtracking==0) )
                                {

                                                                               or =  new OrNode(or, exp2);
                                                                               or.Col= OR2.CharPositionInLine;
                                                                               or.Row = OR2.Line;

                                }

                            }
                            break;

                        default:
                            goto loop2;
                    }
                } while (true);

                loop2:
                    ;	// Stops C# compiler whining that label 'loop2' has no statements

            }

        }
        catch (RecognitionException re)
        {
            ReportError(re);
            Recover(input,re);
        }
        finally
        {
        }
        return or;
    }
示例#33
0
		private Node ParseExpression()
		{
			Node n = ParseSequence();
			Token t = PeekToken();
			for (;;)
			{
				switch (t)
				{
				case Token.End:
				case Token.RParen:
				case Token.Cut:
					return n;
				default:
					Expect(Token.Or);
					n = new OrNode(n, ParseSequence());
					break;
				}
				t = PeekToken();

			}
		}