Пример #1
0
        /// <summary>
        /// Execute the logical expression.
        /// exp: (a AND b)
        ///
        /// Only bool type are authorized.
        /// </summary>
        /// <param name="exprExecResult"></param>
        /// <param name="exprComparison"></param>
        /// <param name="exprExecBase"></param>
        /// <returns></returns>
        private bool ExecExpressionLogical(ExecResult exprExecResult, ExprLogical exprLogical, out ExpressionExecBase exprExecBase)
        {
            exprExecBase = null;

            //----first step is to execute both operands
            ExpressionExecBase exprExecBaseLeft;

            ExecExpression(exprExecResult, exprLogical.ExprLeft, out exprExecBaseLeft);

            ExpressionExecBase exprExecBaseRight;

            ExecExpression(exprExecResult, exprLogical.ExprRight, out exprExecBaseRight);

            //---Are the operands boolean type?
            ExprExecValueBool exprExecValueLeftBool = exprExecBaseLeft as ExprExecValueBool;

            if (exprExecValueLeftBool != null)
            {
                // decode the right operand, should be a bool value too
                ExprExecValueBool exprExecValueRightBool = exprExecBaseRight as ExprExecValueBool;
                if (exprExecValueRightBool == null)
                {
                    // the type of both operands mismatch!
                    exprExecResult.AddErrorExec(ErrorCode.ExprLogicalOperandsTypeMismatchBoolExpected, "Position", exprLogical.ExprRight.Token.Position.ToString());
                    return(false);
                }

                ExprExecValueBool exprValueBoolResult = new ExprExecValueBool();

                // is the operator AND?
                if (exprLogical.Operator == OperatorLogicalCode.And)
                {
                    // ok, execute the comparison
                    exprValueBoolResult.Value = exprExecValueLeftBool.Value && exprExecValueRightBool.Value;
                    exprExecBase = exprValueBoolResult;
                    return(true);
                }

                // is the operator OR?
                if (exprLogical.Operator == OperatorLogicalCode.Or)
                {
                    // ok, execute the comparison
                    exprValueBoolResult.Value = (exprExecValueLeftBool.Value || exprExecValueRightBool.Value);
                    exprExecBase = exprValueBoolResult;
                    return(true);
                }

                // is the operator XOR?
                if (exprLogical.Operator == OperatorLogicalCode.Xor)
                {
                    // ok, execute the comparison, the operator doesn't exists so do firts a OR
                    exprValueBoolResult.Value = (exprExecValueLeftBool.Value || exprExecValueRightBool.Value);

                    // the xor case: both operands are true so the result is false
                    if (exprExecValueLeftBool.Value && exprExecValueRightBool.Value)
                    {
                        exprValueBoolResult.Value = false;
                    }

                    exprExecBase = exprValueBoolResult;
                    return(true);
                }

                // other operators are not allowed on the boolean type (only bool)
                exprExecResult.AddErrorExec(ErrorCode.ExprLogicalOperatorNotAllowed, "Position", exprLogical.ExprLeft.Token.Position.ToString(), "Operator", exprLogical.Operator.ToString());

                return(false);
            }


            //---Are the operands others type?  -> error
            exprExecResult.AddErrorExec(ErrorCode.ExprLogicalOperandTypeNotAllowed, "Position", exprLogical.ExprLeft.Token.Position.ToString(), "Token", exprExecBaseLeft.GetType().ToString());
            return(false);
        }
Пример #2
0
        /// <summary>
        /// analyze and return the list of variables and functionCalls found in the expression to define before execute it.
        /// Do also some checks.
        /// </summary>
        /// <param name="exprParseResult"></param>
        /// <param name="expr"></param>
        /// <returns></returns>
        private bool AnalyzeSyntaxTree(ParseResult result, ExpressionBase expr)
        {
            //----is it a final operand?
            ExprFinalOperand exprFinalOperand = expr as ExprFinalOperand;

            if (exprFinalOperand != null)
            {
                if (exprFinalOperand.ContentType == OperandType.ObjectName)
                {
                    // save the objectName (variable)
                    result.AddVariable(exprFinalOperand.Operand);
                }
                return(true);
            }

            //----is it a function call?
            ExprFunctionCall exprFunctionCall = expr as ExprFunctionCall;

            if (exprFunctionCall != null)
            {
                // scan parameters of the function call
                foreach (ExpressionBase exprParam in exprFunctionCall.ListExprParameters)
                {
                    AnalyzeSyntaxTree(result, exprParam);
                }
                result.AddFunctionCall(exprFunctionCall.FunctionName, exprFunctionCall.ListExprParameters.Count);
                return(true);
            }

            //----is it an expression comparison?
            ExprComparison exprComparison = expr as ExprComparison;

            if (exprComparison != null)
            {
                AnalyzeSyntaxTree(result, exprComparison.ExprLeft);
                AnalyzeSyntaxTree(result, exprComparison.ExprRight);
                return(true);
            }

            //----is it an expression logical?
            ExprLogical exprLogical = expr as ExprLogical;

            if (exprLogical != null)
            {
                AnalyzeSyntaxTree(result, exprLogical.ExprLeft);
                AnalyzeSyntaxTree(result, exprLogical.ExprRight);
                return(true);
            }

            //----is it an expression logical NOT?
            ExprLogicalNot exprLogicalNot = expr as ExprLogicalNot;

            if (exprLogicalNot != null)
            {
                AnalyzeSyntaxTree(result, exprLogicalNot.ExprBase);
                return(true);
            }

            //----is it an expression calculation?
            ExprCalculation exprCalculation = expr as ExprCalculation;

            if (exprCalculation != null)
            {
                // analyze all operands of the calculation expression
                bool res = true;
                foreach (ExpressionBase exprChild in exprCalculation.ListExprOperand)
                {
                    res = res && AnalyzeSyntaxTree(result, exprChild);
                }

                //AnalyzeSyntaxTree(result, exprCalculation.ExprLeft);
                //AnalyzeSyntaxTree(result, exprCalculation.ExprRight);
                return(res);
            }

            //----is it a set value expression ?
            // todo:


            throw new Exception("todo: AnalyzeSyntaxTree(), expression type not yet implemented!");
        }
Пример #3
0
        /// <summary>
        /// start the execution, analyze and return the list of variables to create.
        /// todo: recréer un syntax tree, avec des valeurs!
        ///
        /// -->Doit renvoyer comme résultat un objet de type ExprValueXXX, non?? (si pas d'erreur).
        /// </summary>
        /// <returns></returns>
        private bool ExecExpression(ExecResult exprExecResult, ExpressionBase expr, out ExpressionExecBase exprExecBase)
        {
            exprExecBase = null;

            //----is it a final operand (value, var or call function)?
            ExprFinalOperand finalOperand = expr as ExprFinalOperand;

            if (finalOperand != null)
            {
                return(ExecExpressionFinalOperand(exprExecResult, finalOperand, out exprExecBase));
            }

            //----is it a comparison expression?
            ExprComparison exprComparison = expr as ExprComparison;

            if (exprComparison != null)
            {
                // execute the expression, execute the right part, execute the left part, then exec the expr (as 2 value operands)
                return(ExecExpressionComparison(exprExecResult, exprComparison, out exprExecBase));
            }


            //----is it a logical expression (bin/2 operands)?
            ExprLogical exprLogical = expr as ExprLogical;

            if (exprLogical != null)
            {
                return(ExecExpressionLogical(exprExecResult, exprLogical, out exprExecBase));
            }

            //----is it a NOT logical expression?
            ExprLogicalNot exprLogicalNot = expr as ExprLogicalNot;

            if (exprLogicalNot != null)
            {
                return(ExecExpressionLogicalNot(exprExecResult, exprLogicalNot, out exprExecBase));
            }

            //----is it a calculation expression?
            ExprCalculation exprCalculation = expr as ExprCalculation;

            if (exprCalculation != null)
            {
                // execute the expression, execute the right part, execute the left part, then exec the expr (as 2 value operands)
                return(ExecExpressionCalculation(exprExecResult, exprCalculation, out exprExecBase));
            }

            //----is it function call?
            ExprFunctionCall exprFunctionCall = expr as ExprFunctionCall;

            if (exprFunctionCall != null)
            {
                return(ExecExpressionFunctionCall(exprExecResult, exprFunctionCall, out exprExecBase));
            }


            //----is it a setValue expression?
            // todo: future

            // todo: error, expression not yet implemented!!
            exprExecResult.AddErrorExec(ErrorCode.ExpressionTypeNotYetImplemented, "Expr", expr.GetType().ToString());
            return(false);
        }