public Expression CompileBinOp(AstBinary bo) { return(bo.IsAssign ? CompileAssign(bo) : CompileBinOp(bo.Source, bo.Type, CompileExpression(bo.Left), CompileExpression(bo.Right))); }
AstBinary ProcessBinaryNode(AstBinary astBinary, bool inList) { var safeIsInRightSideOfBinary = _isInRightSideOfBinary; DescendNode(astBinary.Left); _isInRightSideOfBinary = true; DescendNode(astBinary.Right); _isInRightSideOfBinary = safeIsInRightSideOfBinary; return(astBinary); void DescendNode(AstNode node) { Stack.Add(node); Before(node, inList); Stack.Pop(); } }
private Func <decimal, decimal, decimal> GetDecimalOp(AstBinary binary) { switch (binary.Name) { case "+": return((a, b) => a + b); case "-": return((a, b) => a - b); case "*": return((a, b) => a * b); case "/": return((a, b) => a / b); default: throw new NotSupportedException(string.Format("Binary operator is not supported: {0}", binary.Name)); } }
public object Visit(AstBinary binary) { return(GetDecimalOp(binary)(EvaluateDecimal(binary.Left), EvaluateDecimal(binary.Right))); }
public string Visit(AstBinary binary) { return(string.Format("({0} {1} {2})", binary.Left.Accept(this), binary.Name, binary.Right.Accept(this))); }
public Expression Visit(AstBinary binary) { return(Expression.MakeBinary(ResolveBinaryType(binary.Name), binary.Left.Accept(this), binary.Right.Accept(this))); }
Expression CompileAssign(AstBinary e) { var lval = ResolveExpression(e.Left, null); if (lval.IsInvalid) { return(Expression.Invalid); } var right = CompileExpression(e.Right); // Incremental assign-operators (+=, -= etc.) if (e.Type != AstBinaryType.Assign) { // Special case for +=, -= on events if (lval.ExpressionType == PartialExpressionType.Event) { var p = lval as PartialEvent; var obj = p.Object; if (obj != null) { Transforms.TryCreateReadonlyValueFieldIndirection(Namescope, ref obj); } switch (e.Type) { case AstBinaryType.AddAssign: return(new AddListener(e.Source, obj, p.Event, CompileImplicitCast(e.Source, p.Event.ReturnType, right))); case AstBinaryType.SubAssign: return(new RemoveListener(e.Source, obj, p.Event, CompileImplicitCast(e.Source, p.Event.ReturnType, right))); } } right = CompileBinOp(e.Source, e.RemoveAssign, CompilePartial(lval), right); } switch (lval.ExpressionType) { case PartialExpressionType.ArrayElement: { var p = lval as PartialArrayElement; return(new StoreElement(e.Source, p.Object, p.Index, CompileImplicitCast(right.Source, p.ElementType, right))); } case PartialExpressionType.Variable: { var p = lval as PartialVariable; return(new StoreLocal(e.Source, p.Variable, CompileImplicitCast(right.Source, p.Variable.ValueType, right))); } case PartialExpressionType.Parameter: { var p = lval as PartialParameter; return(new StoreArgument(e.Source, p.Function, p.Index, CompileImplicitCast(right.Source, p.Parameter.Type, right))); } case PartialExpressionType.Field: { var p = lval as PartialField; return(new StoreField(e.Source, VerifyLValue(p.Object) ? p.Object : Expression.Invalid, p.Field, CompileImplicitCast(right.Source, p.Field.ReturnType, right))); } case PartialExpressionType.Property: { var p = lval as PartialProperty; var s = CompileImplicitCast(right.Source, p.Property.ReturnType, right); return(p.Property.SetMethod == null ? Error(lval.Source, ErrorCode.E2070, "The property " + p.Property.Quote() + " has no setter accessor") : new SetProperty(e.Source, p.Object, p.Property, s)); } case PartialExpressionType.Event: { var p = lval as PartialEvent; var s = CompileImplicitCast(right.Source, p.Event.ReturnType, right); return(p.Event.ImplicitField == null ? Error(lval.Source, ErrorCode.E2071, "The event " + p.Event.Quote() + " has no implicit field and can only be used before '+=' or '-='") : new StoreField(e.Source, p.Object, p.Event.ImplicitField, s)); } case PartialExpressionType.Indexer: { var p = lval as PartialIndexer; var s = CompileImplicitCast(right.Source, p.Indexer.ReturnType, right); return(p.Indexer.SetMethod == null ? Error(lval.Source, ErrorCode.E2026, "The indexer " + p.Indexer.Quote() + " has no setter accessor") : new SetProperty(e.Source, p.Object, p.Indexer, s, p.Arguments)); } case PartialExpressionType.This: { return(!IsFunctionScope ? Error(lval.Source, ErrorCode.E0000, "'this' not allowed in current context") : new StoreThis(e.Source, CompileImplicitCast(right.Source, Function.DeclaringType, right))); } } return(Error(e.Left.Source, ErrorCode.E2027, "Expression of type <" + lval.ExpressionType + "> cannot be used as left-hand side in an assignment")); }
public void WriteBinary(AstBinary a) { Write(a.Left); Write(a.Source); Write(a.Right); }
public IEnumerable <AstNode> Visit(AstBinary binary) { yield return(binary.Left); yield return(binary.Right); }
public virtual T Visit(AstBinary binary) { return(Default(binary)); }