private StatementType AnalyseExpression(IExpressionNode node)
        {
            switch (node.GetNodeType())
            {
            case NodeType.LogicalExpression:
                var logicalNode = (LogicalExpressionNode)node;
                return(Analyze(logicalNode));

            case NodeType.ComparisonExpression:
                var comparisonNode = (ComparisonExpressionNode)node;
                return(Analyze(comparisonNode));

            case NodeType.ArthimetricExpression:
                var arthimetric = (ArthimetricExpressionNode)node;
                return(Analyze(arthimetric));

            case NodeType.TextConcatination:
                var textNode = (TextConcatinationNode)node;
                return(Analyze(textNode));

            case NodeType.Literal:
            case NodeType.Identifier:
                return(StatementTypeEvaluator.GetStatementType(node));
            }

            throw new UnknownNodeTypeException(string.Format("We don't know what to do with this node: {0}", node.GetNodeType()));
        }
Example #2
0
        public ExpressionValue ParseExpressionNode(IExpressionNode node)
        {
            switch (node.GetNodeType())
            {
            case NodeType.ARTHIMETRIC_EXPRESSION:
                return(ParseArthimeticNode(node as ArthimetricExpressionNode));

            case NodeType.COMPARISON_EXPRESSION:
                return(ParseComparisonNode(node as ComparisonExpressionNode));

            case NodeType.LOGICAL_EXPRESSION:
                return(ParseLogicalNode(node as LogicalExpressionNode));

            case NodeType.IDENTIFIER:
                return(ParseIdentifyerNode(node as IdentifierNode));

            case NodeType.LITERAL:
                return(ParseLiteralNode(node as LiteralNode));

            default:
                throw new NotImplementedException();
            }
        }
Example #3
0
        private bool AnalyseExpression(IExpressionNode node)
        {
            switch (node.GetNodeType())
            {
            case NodeType.LOGICAL_EXPRESSION:
            case NodeType.COMPARISON_EXPRESSION:
            case NodeType.ARTHIMETRIC_EXPRESSION:
                var statementNode = (ExpressionNode)node;
                var leftResult    = AnalyseExpression(statementNode.Left);
                var rightResult   = AnalyseExpression(statementNode.Right);
                return(leftResult == rightResult);

            case NodeType.LITERAL:
                return(true);

            case NodeType.IDENTIFIER:
                var valueNode = (IdentifierNode)node;
                return(IsIdentiierInSymbolTable(valueNode));

            default:
                throw new UnknownNodeTypeException(string.Format("We don't know what to do with a {0} node.", node.GetNodeType()));
            }
        }
        private StatementType AnalyseExpression(IExpressionNode node)
        {
            switch (node.GetNodeType())
            {
            case NodeType.LOGICAL_EXPRESSION:
                var logicalNode = (LogicalExpressionNode)node;
                return(Analyze(logicalNode));

            case NodeType.COMPARISON_EXPRESSION:
                var comparisonNode = (ComparisonExpressionNode)node;
                return(Analyze(comparisonNode));

            case NodeType.ARTHIMETRIC_EXPRESSION:
                var arthimetric = (ArthimetricExpressionNode)node;
                return(Analyze(arthimetric));

            case NodeType.LITERAL:
            case NodeType.IDENTIFIER:
                return(GetStatementType(node));
            }

            throw new UnknownNodeTypeException(string.Format("We don't know what to do with this node: {0}", node.GetNodeType()));
        }
        private bool AnalyseExpression(IExpressionNode node)
        {
            switch (node.GetNodeType())
            {
            case NodeType.LogicalExpression:
            case NodeType.ComparisonExpression:
            case NodeType.ArthimetricExpression:
            case NodeType.TextConcatination:
                var statementNode = (ExpressionNode)node;
                var leftResult    = AnalyseExpression(statementNode.Left);
                var rightResult   = AnalyseExpression(statementNode.Right);
                return(leftResult == rightResult);

            case NodeType.Literal:
                return(true);

            case NodeType.Identifier:
                var valueNode = (IdentifierNode)node;
                return(IsIdentiierInSymbolTable(valueNode));

            default:
                throw new UnknownNodeTypeException(string.Format("We don't know what to do with a {0} node.", node.GetNodeType()));
            }
        }