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); }
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)); }
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(); } }
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); }
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>(); } }
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 ); }
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); }
public BinaryExpression(Expression left, OperatorExpression op, Expression right) { this.Left = left; this.op = op; this.Right = right; }
public TagExpression(OperatorExpression expression) => Tags = expression;
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(); }
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); }
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); }
/// <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(); } }
public DimensionExpression(OperatorExpression expression) => Dimension = expression;
public virtual LinqExpression VisitOperator(OperatorExpression op) { throw new NotImplementedException(op.ToString()); }