示例#1
0
 public void Positionne_l_expression_en_expression2()
 {
     var intVar2 = new OperandeVariable(intId, "num2");
       var tmp = new OperatorExpression(intVar, OPERATOR.EQUAL);
       tmp = (OperatorExpression)tmp.Set(2, intVar2);
       Assert.AreSame(intVar2, tmp.Expression2);
 }
 public void Positionne_expression_2()
 {
     var tmp = new OperandeVariable(intId, "nom");
       var ope = new OperatorExpression(tmp, OPERATOR.PLUS);
       ope.Expression2 = tmp;
       Assert.AreEqual(tmp, ope.Expression2);
 }
示例#3
0
 void PrintExpression(OperatorExpression e, int d)
 {
     SayLn("OperatorExpression(");
     Indent(d + 1);
     switch (e.Op)
     {
         case Operator.Plus: Say("PLUS"); break;
         case Operator.Minus: Say("MINUS"); break;
         case Operator.Times: Say("MUL"); break;
         case Operator.Divide: Say("DIV"); break;
         case Operator.Equal: Say("EQ"); break;
         case Operator.NotEqual: Say("NE"); break;
         case Operator.LessThan: Say("LT"); break;
         case Operator.LessEqual: Say("LE"); break;
         case Operator.GreaterThan: Say("GT"); break;
         case Operator.GreaterEqual: Say("GE"); break;
         default:
             throw new Exception("Print.PrintExpression.OperatorExpression");
     }
     SayLn(",");
     PrintExpression(e.Left, d + 1);
     SayLn(",");
     PrintExpression(e.Right, d + 1);
     Say(")");
 }
 public void Doit_avoir_3_elements()
 {
     var tmpVar = new OperandeVariable(classId, "maVariable");
       var tmp = new OperatorExpression(tmpVar, OPERATOR.EQUAL);
       var visitor = new VisualisationVisitor(ref registry);
       List<IElement> lst = visitor.Visit(tmp);
       Assert.AreEqual(3, lst.Count);
 }
        public void Doit_retourner_id_class_que_operation()
        {
            var visitor = new ReturnVisitor(ref registry);

              var tmp = new OperandeVariable(classId, "num");
              var tmp2 = new OperatorExpression(tmp, OPERATOR.EQUAL);

              Assert.AreEqual(classId, visitor.Visit(tmp2));
        }
示例#6
0
 public void Positionne_l_expression_en_deuxième_expression_de_expression2()
 {
     var intVar2 = new OperandeVariable(intId, "num2");
       var ope2 = new OperatorExpression(intVar2, OPERATOR.EQUAL);
       var ope1 = new OperatorExpression(intVar, OPERATOR.EQUAL);
       ope1 = (OperatorExpression)ope1.Set(2, ope2);
       ope1 = (OperatorExpression)ope1.Set(4, intVar2);
       Assert.AreSame(intVar2, ((OperatorExpression)ope1.Expression2).Expression2);
 }
        public void Doit_retourner_id_boolean_pour_operateur_AND_OR_ARE_EQUAL()
        {
            var visitor = new ReturnVisitor(ref registry);

              var tmp3 = registry.AddPrimitiveClass("boolean", DATA_TYPE.BOOLEAN);
              var tmp = new OperandeVariable(classId, "num");
              var tmp2 = new OperatorExpression(tmp, OPERATOR.AND);
              Assert.AreEqual(tmp3, visitor.Visit(tmp2));
              tmp2 = new OperatorExpression(tmp, OPERATOR.OR);
              Assert.AreEqual(tmp3, visitor.Visit(tmp2));
              tmp2 = new OperatorExpression(tmp, OPERATOR.ARE_EQUAL);
              Assert.AreEqual(tmp3, visitor.Visit(tmp2));
        }
            ExpressionType TranslateExpression(OperatorExpression e)
            {
                ExpressionType eLeft  = TranslateExpression(e.Left);
                ExpressionType eRight = TranslateExpression(e.Right);

                if (e.Op == Operator.Plus || e.Op == Operator.Minus || e.Op == Operator.Times || e.Op == Operator.Divide)
                {
                    CheckInteger(e.Left.Pos, eLeft);
                    CheckInteger(e.Right.Pos, eRight);
                    return(new ExpressionType(Translate.TranslateCalculateExp((Tree.BINOP.Op)e.Op, eLeft.Exp, eRight.Exp), Types.Type._int));
                }
                else if (e.Op == Operator.Equal || e.Op == Operator.NotEqual)
                {
                    Types.Type ty = checkEqualType(e.Pos, eLeft, eRight);
                    if (ty.CoerceTo(Types.Type._string))
                    {
                        return(new ExpressionType(Translate.TranslateStringRelExp(ConvertOp(e.Op), eLeft.Exp, eRight.Exp), Types.Type._int));
                    }
                    else
                    {
                        return(new ExpressionType(Translate.TranslateRelExp(ConvertOp(e.Op), eLeft.Exp, eRight.Exp), Types.Type._int));
                    }
                }
                else
                {
                    Types.Type ty = CheckCmpType(e.Pos, eLeft, eRight);
                    if (ty.CoerceTo(Types.Type._string))
                    {
                        return(new ExpressionType(Translate.TranslateStringRelExp(ConvertOp(e.Op), eLeft.Exp, eRight.Exp), Types.Type._int));
                    }
                    else
                    {
                        return(new ExpressionType(Translate.TranslateRelExp(ConvertOp(e.Op), eLeft.Exp, eRight.Exp), Types.Type._int));
                    }
                }
            }
 public BinaryExpression(double left, OperatorExpression op, double right)
 {
     Init(Expression.Number(left), op, Expression.Number(right));
 }
 public BinaryExpression(Expression left, OperatorExpression op, Expression right)
 {
     Init(left, op, right);
 }
 private void Init(Expression left, OperatorExpression op, Expression right)
 {
     this.Left  = left;
     this.op    = op;
     this.Right = right;
 }
 public static BinaryExpression Binary(string left, OperatorExpression op, string right)
 {
     return(new BinaryExpression(left, op, right));
 }
 public static BinaryExpression Binary(double left, OperatorExpression op, double right)
 {
     return(new BinaryExpression(left, op, right));
 }
 public EvaluationException(EvaluationResult left, OperatorExpression op, EvaluationResult right)
     : this(left, op, right, null)
 {
 }
        StateValue Operate(OperatorExpression operatorExpression, ItemId itemId)
        {
            StateValue GetOperand(int index) => EvaluateExpression(operatorExpression.Operands[index], itemId);

            switch (operatorExpression.Operator)
            {
            case Operator.Not:
                return(new StateValue(!GetOperand(0).ToBool()));

            case Operator.Minus:
                return(new StateValue(-GetOperand(0).ToDouble()));

            case Operator.Equals:
                return(new StateValue(Mathf.Approximately(GetOperand(0).ToFloat(), GetOperand(1).ToFloat())));

            case Operator.NotEquals:
                return(new StateValue(!Mathf.Approximately(GetOperand(0).ToFloat(), GetOperand(1).ToFloat())));

            case Operator.GreaterThan:
                return(new StateValue(GetOperand(0).ToDouble() > GetOperand(1).ToDouble()));

            case Operator.GreaterThanOrEqual:
                return(new StateValue(GetOperand(0).ToDouble() >= GetOperand(1).ToDouble()));

            case Operator.LessThan:
                return(new StateValue(GetOperand(0).ToDouble() < GetOperand(1).ToDouble()));

            case Operator.LessThanOrEqual:
                return(new StateValue(GetOperand(0).ToDouble() <= GetOperand(1).ToDouble()));

            case Operator.Add:
                return(new StateValue(GetOperand(0).ToDouble() + GetOperand(1).ToDouble()));

            case Operator.Multiply:
                return(new StateValue(GetOperand(0).ToDouble() * GetOperand(1).ToDouble()));

            case Operator.Subtract:
                return(new StateValue(GetOperand(0).ToDouble() - GetOperand(1).ToDouble()));

            case Operator.Divide:
                return(new StateValue(GetOperand(0).ToDouble() / GetOperand(1).ToDouble()));

            case Operator.Modulo:
                return(new StateValue(GetOperand(0).ToDouble() % GetOperand(1).ToDouble()));

            case Operator.And:
                return(new StateValue(GetOperand(0).ToBool() && GetOperand(1).ToBool()));

            case Operator.Or:
                return(new StateValue(GetOperand(0).ToBool() || GetOperand(1).ToBool()));

            case Operator.Condition:
                return(GetOperand(0).ToBool() ? GetOperand(1) : GetOperand(2));

            case Operator.Min:
                return(new StateValue(Math.Min(GetOperand(0).ToDouble(), GetOperand(1).ToDouble())));

            case Operator.Max:
                return(new StateValue(Math.Max(GetOperand(0).ToDouble(), GetOperand(1).ToDouble())));

            case Operator.Clamp:
                return(new StateValue(Math.Min(Math.Max(GetOperand(0).ToDouble(), GetOperand(1).ToDouble()), GetOperand(2).ToDouble())));

            default: throw new NotImplementedException();
            }
        }
示例#16
0
        private static BitsValue DoAssignment(ref CaseContext ctx, OperatorExpression op)
        {
            if (!op.Left.IsWriteable)
            {
                throw new LogicEngineException("Expected a writeable expression", op);
            }

            if (!op.Right.IsReadable)
            {
                throw new LogicEngineException("Expected a readable expression", op);
            }

            var lhs = op.Left;

            var  value = GetValue(ref ctx, op.Right);
            int  start, end;
            bool isRanged = false;

            if (lhs is IndexerExpression indexer)
            {
                GetRange(ref ctx, indexer, value.Length, out start, out end);
                lhs      = indexer.Operand;
                isRanged = true;
            }
            else
            {
                start = 0;
                end   = GetLength(ctx.Machine, lhs);
            }

            if (end == 0)
            {
                end = start + value.Length;
            }

            if (value.Length > end - start)
            {
                throw new LogicEngineException("Value doesn't fit in range", op);
            }

            Span <bool> bits = stackalloc bool[value.Length];

            value.FillBits(bits);

            if (lhs is SlotExpression slot)
            {
                switch (slot.Slot)
                {
                case Slots.Out:
                    if (end > ctx.Machine.OutputCount)
                    {
                        throw new LogicEngineException("Range out of bounds for outputs", op);
                    }

                    ctx.Machine.SetOutputs(start, value);
                    break;

                case Slots.Memory:
                    if (end > ctx.Machine.Memory.Capacity)
                    {
                        throw new LogicEngineException("Range out of bounds for memory", op);
                    }

                    //ctx.Machine.Memory.Write(start, bits);
                    break;

                default:
                    throw new LogicEngineException("Invalid slot on expression", op);
                }
            }
            else if (lhs is VariableAccessExpression var)
            {
                if (!isRanged)
                {
                    ctx.Set(var.Name, value);
                }
                else
                {
                    //var val = ctx.Get(var.Name, var);
                    throw new LogicEngineException("Cannot index variable", var);
                }
            }

            return(value);
        }
示例#17
0
 public void Jete_exception_si_position_inattendue()
 {
     var tmp = new OperatorExpression(intVar, OPERATOR.EQUAL);
       Assert.AreSame(intVar, tmp.Set(1, intVar));
 }
        private void Visit(OperatorExpression expr)
        {
            var convert = true;

            if (expr.Operator == Operator.Assign)
            {
                VisitAssignment(expr.Left, expr.Right);
            }
            else if (expr.Operator == Operator.BitShiftLeft || expr.Operator == Operator.BitShiftRight)
            {
                DoBitshift();
                convert = false;
            }
            else if (!DoComparison())
            {
                Visit(expr.Left);
                BitsValueToNumber();
                Visit(expr.Right);
                BitsValueToNumber();

                switch (expr.Operator)
                {
                case Operator.Add:
                    Generator.Add();
                    break;

                case Operator.Subtract:
                    Generator.Sub();
                    break;

                case Operator.Modulo:
                    Generator.Rem(true);
                    break;

                case Operator.Multiply:
                    Generator.Mul();
                    break;

                case Operator.Divide:
                    Generator.Div(true);
                    break;

                case Operator.And:
                    Generator.And();
                    break;

                case Operator.Or:
                    Generator.Or();
                    break;

                case Operator.Xor:
                    Generator.Xor();
                    break;
                }
            }

            if (convert)
            {
                NumberToBitsValue();
            }

            void DoBitshift()
            {
                // Load left member (number), and store in Temp1
                Visit(expr.Left);
                Generator.Dup();
                Generator.Stloc(Temp1);
                BitsValueToNumber();

                // Load right member (shift amount), and store in Temp2
                Visit(expr.Right);
                BitsValueToNumber();
                Generator.Dup();
                Generator.Stloc(Temp2);

                // Do the shift
                if (expr.Operator == Operator.BitShiftLeft)
                {
                    Generator.Shl();
                }
                else
                {
                    Generator.Shr(true);
                }

                // Calculate result length (add or subtract shift amount from operand length)
                Generator.Ldloc(Temp1);
                ValueLength();
                Generator.Ldloc(Temp2);
                Generator.Conv <int>();

                if (expr.Operator == Operator.BitShiftLeft)
                {
                    Generator.Add();
                }
                else
                {
                    Generator.Sub();
                }

                NumberToBitsValue(true);
            }

            bool DoComparison()
            {
                switch (expr.Operator)
                {
                case Operator.NotEquals:
                    EmitCompare(() => Generator.Ldc_I4(1), () =>
                    {
                        Generator.Ceq();
                        Generator.Sub();
                    });
                    break;

                case Operator.Equals:
                    EmitCompare(null, () => Generator.Ceq());
                    break;

                case Operator.Greater:
                    EmitCompare(null, () => Generator.Cgt(true));
                    break;

                case Operator.GreaterOrEqual:
                    EmitCompare(null, () =>
                    {
                        Generator.Clt(true);
                        Generator.Ldc_I4(0);
                        Generator.Ceq();
                    });
                    break;

                case Operator.Lesser:
                    EmitCompare(null, () => Generator.Clt(true));
                    break;

                case Operator.LesserOrEqual:
                    EmitCompare(null, () =>
                    {
                        Generator.Cgt(true);
                        Generator.Ldc_I4(0);
                        Generator.Ceq();
                    });
                    break;

                default:
                    return(false);
                }

                return(true);
            }

            void EmitCompare(Action before, Action after)
            {
                before?.Invoke();

                Visit(expr.Left);
                BitsValueToNumber();

                Visit(expr.Right);
                BitsValueToNumber();

                after?.Invoke();
                Generator.Conv <ulong>();
            }
        }
示例#19
0
        public void Select_With_Inner_Join_Condition_With_Complex_Expressions()
        {
            // Exercise
            SelectStatement statement = ParserFactory.Execute <SelectStatement>(@"

                select fielda 

                from table1 t1 

                join table2 as t2 
                  on (t1.field1 + 150) / 12 = ( t2.field2 + t1.fielda )
                "
                                                                                ).First();

            // Verify outcome
            Assert.IsNotNull(statement);

            // Test From
            Assert.AreEqual(1, statement.From.Count);
            Assert.AreEqual("table1", statement.From[0].Name);
            Assert.AreEqual("t1", statement.From[0].Alias.Name);

            // Test Join
            Assert.AreEqual(1, statement.From[0].Joins.Count);

            Join join = statement.From[0].Joins[0];

            Assert.AreEqual("table2", join.Name);
            Assert.AreEqual("t2", join.Alias.Name);

            Assert.AreEqual(JoinType.Join, join.Type);

            CriteriaExpression expr = join.Condition as CriteriaExpression;

            Assert.AreEqual("=", expr.Operator);
            Assert.IsTrue(expr.Left is OperatorExpression);

            var leftExpression = (OperatorExpression)expr.Left;

            Assert.AreEqual("/", leftExpression.Operator);

            Assert.IsTrue(leftExpression.Left is NestedExpression);
            var leftLeftExpression = (NestedExpression)leftExpression.Left;

            Assert.IsTrue(leftLeftExpression.Expression is OperatorExpression);

            OperatorExpression leftOperatorExpression = (OperatorExpression)leftLeftExpression.Expression;

            Assert.AreEqual("t1.field1", leftOperatorExpression.Left.Value);
            Assert.AreEqual("+", leftOperatorExpression.Operator);
            Assert.AreEqual("150", leftOperatorExpression.Right.Value);

            IdentifierExpression rightIdentifierExpression = (IdentifierExpression)leftExpression.Right;

            Assert.AreEqual("12", rightIdentifierExpression.Value);

            //var rightExpression = ( NestedExpression )expr.Right;
            //Assert.AreEqual( "t2", rightExpression.Parts[ 0 ] );
            //Assert.AreEqual( "field2", rightExpression.Parts[ 1 ] );
            //Assert.AreEqual( "t2.field2", expr.Right.Value );
        }
示例#20
0
文件: Parser.cs 项目: Trevol/MathEval
        private static IArithExpression ParseOperator(Token operatorToken, IArithExpression lOperand, TokenCursor tokens)
        {
            var rOperand = ParseRightOperand(tokens.Next(), operatorToken, tokens);

            return(OperatorExpression.Create(operatorToken.Value, lOperand, rOperand));
        }
 public void Positionne_type_d_operation()
 {
     var intVar = new OperandeVariable(intId, "nom");
       var ope = new OperatorExpression(intVar, OPERATOR.PLUS);
       Assert.AreEqual(OPERATOR.PLUS, ope.Operator);
 }
 public void Positionne_l_expression_de_gauche()
 {
     var intVar = new OperandeVariable(intId, "nom");
       var ope = new OperatorExpression(intVar, OPERATOR.PLUS);
       Assert.AreEqual(intVar, ope.Expression1);
 }
示例#23
0
 public BinaryExpression(Expression left, OperatorExpression op, Expression right)
 {
     this.Left  = left;
     this.op    = op;
     this.Right = right;
 }
示例#24
0
 public TagExpression(OperatorExpression expression)
 => Tags = expression;
示例#25
0
 public void Retourne_l_element_positionné_quand_position_zero()
 {
     var tmp = new OperatorExpression(intVar, OPERATOR.EQUAL);
       Assert.AreSame(intVar, ((OperatorExpression)tmp.Set(0, intVar)).Expression1);
 }
        public void TestThatEvalFailsIfInnerExpressionCannotBeEvaluated()
        {
            var concat = new OperatorExpression(AnyValidOperator, AnyUnevaluatableExpr);

            concat.TryEvaluate(EmptyEnvironment, out string value).Should().BeFalse();
        }
示例#27
0
 public static BinaryExpression Binary(Expression left, OperatorExpression op, Expression right)
 {
     return(new BinaryExpression(left, op, right));
 }
 public void Jete_exception_quand_operation_egal()
 {
     var tmp = new OperandeVariable(intId, "nom");
       var tmp2 = new OperatorExpression(tmp, OPERATOR.EQUAL);
       new OperatorExpression(tmp2, OPERATOR.EQUAL);
 }
示例#29
0
 public void Doit_retourner_trois_pour_operateur()
 {
     OperandeVariable operande = new OperandeVariable(classId, "var1");
       IExpression v = new OperatorExpression(operande, OPERATOR.EQUAL);
       Assert.AreEqual(3, v.Count);
 }
示例#30
0
        /// <summary>
        ///     This function handles unsupported features by <see cref="Regen.Flee"/> evaluator by creating temporary
        ///     variables or even changing the type of expression.
        /// </summary>
        /// <remarks>
        /// Because flee does not support arrays, we temporarly store any parsed array
        /// into a variable and then just pass the variable name, letting Regen just fetch it
        /// and pass it around.
        ///</remarks>
        public Expression HandleUnsupported(Expression expr, List <TemporaryVariable> temps, Type caller = null)
        {
            //todo after we support dictionaries, add support here
            switch (expr)
            {
            case NullIdentity _:
            case CharLiteral _:
            case NumberLiteral _:
            case StringLiteral _:
            case BooleanLiteral _:
            case StringIdentity _:
            case ReferenceIdentity _:
            case EmptyExpression _:
                return(expr);

            case ArgumentsExpression argumentsExpression: {
                for (var i = 0; i < argumentsExpression.Arguments.Length; i++)
                {
                    argumentsExpression.Arguments[i] = HandleUnsupported(argumentsExpression.Arguments[i], temps, typeof(ArgumentsExpression));
                }

                return(argumentsExpression);
            }

            case ArrayExpression arrayExpression: {
                for (var i = 0; i < arrayExpression.Values.Length; i++)
                {
                    arrayExpression.Values[i] = HandleUnsupported(arrayExpression.Values[i], temps, typeof(ArrayExpression));
                }

                Data parsedArray = Compute(arrayExpression, temps, typeof(ArrayExpression));
                if (parsedArray is ReferenceData rd)
                {
                    return(IdentityExpression.WrapVariable((string)rd.Value));
                }
                else
                {
                    var temp = new TemporaryVariable(Context, parsedArray).MarkPermanent();
                    return(IdentityExpression.WrapVariable(temp.Name));
                }

                //todo this might lead to memory leaks!
                //temps.Add(temp);
                //if (caller == typeof(RegenCompiler)) { //if this is the first expression that is being parsed
                //    temp.MarkPermanent();
                //}
            }

            case IndexerCallExpression indexerCallExpression: {
                indexerCallExpression.Left      = HandleUnsupported(indexerCallExpression.Left, temps, typeof(IndexerCallExpression));
                indexerCallExpression.Arguments = (ArgumentsExpression)HandleUnsupported(indexerCallExpression.Arguments, temps, typeof(IndexerCallExpression));
                return(indexerCallExpression);
            }

            case CallExpression callExpression: {
                callExpression.FunctionName = HandleUnsupported(callExpression.FunctionName, temps, typeof(CallExpression));
                callExpression.Arguments    = (ArgumentsExpression)HandleUnsupported(callExpression.Arguments, temps, typeof(CallExpression));
                return(callExpression);
            }

            case IdentityExpression identityExpression: {
                //here we turn any string literal into a reference to a variable.
                //if theres no such variable, we assume it is for a functionname of property.
                if (identityExpression.Identity is StringIdentity sr)
                {
                    if (Context.Variables.ContainsKey(sr.Name))
                    {
                        return(new IdentityExpression(ReferenceIdentity.Wrap(sr)));
                    }
                }

                identityExpression.Identity = HandleUnsupported(identityExpression.Identity, temps, caller ?? typeof(IdentityExpression));
                return(identityExpression);
            }

            case HashtagReferenceExpression hashtagReference: {
                var key = $"__{hashtagReference.Number}__";
                return(new IdentityExpression(new ReferenceIdentity(key, new RegexResult()
                    {
                        Value = key, Index = hashtagReference.Matches().First().Index, Length = 1 + hashtagReference.Number.Length
                    })));
            }

            case GroupExpression groupExpression:
                groupExpression.InnerExpression = HandleUnsupported(groupExpression.InnerExpression, temps, caller ?? typeof(GroupExpression));
                return(groupExpression);

            case PropertyIdentity propertyIdentity:
                //todo maybe here we parse Left, store and push? but first invalidate that it is not just a name.
                propertyIdentity.Left  = HandleUnsupported(propertyIdentity.Left, temps, caller ?? typeof(PropertyIdentity));
                propertyIdentity.Right = HandleUnsupported(propertyIdentity.Right, temps, caller ?? typeof(PropertyIdentity));
                return(propertyIdentity);

            case KeyValueExpression keyValueExpression:
                keyValueExpression.Key   = HandleUnsupported(keyValueExpression.Key, temps, typeof(KeyValueExpression));
                keyValueExpression.Value = HandleUnsupported(keyValueExpression.Value, temps, typeof(KeyValueExpression));
                return(keyValueExpression);

            case NewExpression newExpression:
                newExpression.Constructor = HandleUnsupported(newExpression.Constructor, temps, typeof(NewExpression));
                return(newExpression);

            case LeftOperatorExpression leftOperatorExpression: {
                var right = HandleUnsupported(leftOperatorExpression.Right, temps, typeof(LeftOperatorExpression));
                if (OperatorExpression.IsLogicalOperator(leftOperatorExpression.Op))
                {
                    switch (leftOperatorExpression.Op)
                    {
                    case ExpressionToken.NotBoolean:
                        return(new CallExpression("op_not", right));

                    case ExpressionToken.Not:
                        return(new CallExpression("op_inverse", right));

                    default:
                        break;
                    }
                }


                leftOperatorExpression.Right = right;
                return(leftOperatorExpression);
            }

            case OperatorExpression operatorExpression: {
                var left  = HandleUnsupported(operatorExpression.Left, temps, typeof(OperatorExpression));
                var right = HandleUnsupported(operatorExpression.Right, temps, typeof(OperatorExpression));
                if (OperatorExpression.IsLogicalOperator(operatorExpression.Op))
                {
                    switch (operatorExpression.Op)
                    {
                    case ExpressionToken.DoubleEqual:
                        return(new CallExpression("op_equals", left, right));

                    case ExpressionToken.NotEqual:
                        return(new CallExpression("op_notequals", left, right));

                    case ExpressionToken.DoubleAnd:
                    case ExpressionToken.And:
                        return(new CallExpression("op_and", left, right));

                    case ExpressionToken.DoubleOr:
                    case ExpressionToken.Or:
                        return(new CallExpression("op_or", left, right));

                    case ExpressionToken.BiggerOrEqualThat:
                        return(new CallExpression("op_biggerequals", left, right));

                    case ExpressionToken.BiggerThan:
                        return(new CallExpression("op_bigger", left, right));

                    case ExpressionToken.SmallerOrEqualThat:
                        return(new CallExpression("op_smallerequals", left, right));

                    case ExpressionToken.SmallerThan:
                        return(new CallExpression("op_smaller", left, right));

                    case ExpressionToken.ApproxEqual:
                        return(new CallExpression("op_equalsapprox", left, right));

                    default:
                        break;
                    }
                }

                operatorExpression.Left  = left;
                operatorExpression.Right = right;
                return(operatorExpression);
            }

            case RightOperatorExpression rightOperatorExpression:
                rightOperatorExpression.Left = HandleUnsupported(rightOperatorExpression.Left, temps, typeof(RightOperatorExpression));
                return(rightOperatorExpression);

            case ThrowExpression throwExpression:
                throwExpression.Right = HandleUnsupported(throwExpression.Right, temps, typeof(ThrowExpression));
                return(throwExpression);

            case TernaryExpression ternary: {
                ternary.Condition = HandleUnsupported(ternary.Condition, temps, typeof(TernaryExpression));
                ternary.IfTrue    = HandleUnsupported(ternary.IfTrue, temps, typeof(TernaryExpression));
                if (ternary.IfFalse != null)
                {
                    ternary.IfFalse = HandleUnsupported(ternary.IfFalse, temps, typeof(TernaryExpression));
                }
                return(ternary);
            }

            case ForeachExpression foreachExpression:
            case ImportExpression importExpression:
            case InteractableExpression interactableExpression:
            case VariableDeclarationExpression variableExpression:
                throw new NotSupportedException(); //todo support? this should be found in an expression. it is a higher level expression

            case Identity identity:                //this is an abstract class.
                throw new NotSupportedException();

            default:
                throw new NotImplementedException();
            }
        }
示例#31
0
 public DimensionExpression(OperatorExpression expression)
 => Dimension = expression;
示例#32
0
 public virtual LinqExpression VisitOperator(OperatorExpression op)
 {
     throw new NotImplementedException(op.ToString());
 }