public override DynamicMetaObject BindBinaryOperation(BinaryOperationBinder binder, DynamicMetaObject arg)
{
if (Value is SilverInstance) {
string silverName = InteropBinder.MapExpressionType(binder.Operation);
if (silverName == null) {
return InteropBinder.Binary.Bind(binder, this, arg);
}
if (
InteropBinder.InvokeMember.SearchForFunction(((SilverInstance) Value).Class, silverName,
(SilverInstance) Value, L(Arg(arg.Value)), true) != null) {
return
InteropBinder.InvokeMember.Bind(
new InteropBinder.InvokeMember(silverName, new CallInfo(0), Scope), this,
_DMO(DMO(Scope), DMO(Arg(arg.Value))));
}
string clrName = InteropBinder.ToClrOperatorName(silverName);
if (
InteropBinder.InvokeMember.SearchForFunction(((SilverInstance) Value).Class, clrName,
(SilverInstance) Value, L(Arg(arg.Value)), true) != null) {
return
InteropBinder.InvokeMember.Bind(
new InteropBinder.InvokeMember(clrName, new CallInfo(0), Scope), this,
_DMO(DMO(Scope), DMO(Arg(arg.Value))));
}
return InteropBinder.Binary.Bind(binder, this, arg);
}
return InteropBinder.Binary.Bind(binder, this, arg);
}
public override Boolean TryBinaryOperation(BinaryOperationBinder binder, Object arg, out Object result)
{
switch (binder.Operation) {
case ExpressionType.GreaterThan:
case ExpressionType.GreaterThanOrEqual:
case ExpressionType.LessThan:
case ExpressionType.LessThanOrEqual: {
if (!typeof(IComparable).IsAssignableFrom(_targetType))
throw new NotSupportedException(string.Format("Can not perform unary operation '{0}' on type '{1}', is does not implement IComparable", binder.Operation, ReflectionHelper.GetTypeName(_targetType)));
var tmp = ((IComparable) _target).CompareTo(arg);
result = null;
if (binder.Operation == ExpressionType.GreaterThan) result = (tmp > 0);
if (binder.Operation == ExpressionType.GreaterThanOrEqual) result = (tmp >= 0);
if (binder.Operation == ExpressionType.LessThan) result = (tmp < 0);
if (binder.Operation == ExpressionType.LessThanOrEqual) result = (tmp <= 0);
return true;
}
case ExpressionType.Equal: {
result = _target.Equals(arg);
return true;
}
}
throw new NotImplementedException(String.Format("TryBinaryOperation op='{0}' arg='{1}'", binder.Operation, arg));
}
internal override bool BinaryOperation(BinaryOperationBinder binder, Any arg, out Any result)
{
var number = arg as Number;
if (number != null)
{
switch (binder.Operation)
{
case ExpressionType.Add:
result = new Number(Value + number.Value);
break;
case ExpressionType.Subtract:
result = new Number(Value - number.Value);
break;
case ExpressionType.Multiply:
result = new Number(Value * number.Value);
break;
case ExpressionType.Divide:
result = new Number(Value / number.Value);
break;
case ExpressionType.LessThan:
result = Value < number.Value ? Bool.True : Bool.False;
break;
case ExpressionType.LessThanOrEqual:
result = Value <= number.Value ? Bool.True : Bool.False;
break;
default:
throw new ArgumentOutOfRangeException();
}
return true;
}
return base.BinaryOperation(binder, arg, out result);
}
/// <summary>
/// Provides implementation for binary operations. Classes derived from the <see cref="T:System.Dynamic.DynamicObject" /> class can override this method to specify dynamic behavior for operations such as addition and multiplication.
/// </summary>
/// <param name="binder">Provides information about the binary operation. The binder.Operation property returns an <see cref="T:System.Linq.Expressions.ExpressionType" /> object. For example, for the sum = first + second statement, where first and second are derived from the DynamicObject class, binder.Operation returns ExpressionType.Add.</param>
/// <param name="arg">The right operand for the binary operation. For example, for the sum = first + second statement, where first and second are derived from the DynamicObject class, <paramref name="arg" /> is equal to second.</param>
/// <param name="result">The result of the binary operation.</param>
/// <returns>
/// true if the operation is successful; otherwise, false. If this method returns false, the run-time binder of the language determines the behavior. (In most cases, a language-specific run-time exception is thrown.)
/// </returns>
public override bool TryBinaryOperation(BinaryOperationBinder binder, object arg, out object result)
{
result = null;
if (binder.Operation == ExpressionType.LeftShift)
{
result = ((dynamic)(this))(arg);
return true;
}
return false;
}
public override bool TryBinaryOperation(BinaryOperationBinder binder, object arg, out object result)
{
//--- Debbuger Break --- //
if(System.Diagnostics.Debugger.IsAttached)
System.Diagnostics.Debugger.Break();
//--- Debbuger Break --- //
bool res = base.TryBinaryOperation(binder, arg, out result);
return res;
}
public override bool TryBinaryOperation(BinaryOperationBinder binder,
object arg, out object result)
{
bool success = false;
if (binder.Operation == System.Linq.Expressions.ExpressionType.Add)
{
Console.WriteLine("I have to think about that");
success = true;
}
result = this;
return success;
}
public override bool TryBinaryOperation(BinaryOperationBinder binder, object arg, out object result)
{
if(binder.Operation == ExpressionType.LeftShiftAssign)
{
var copy = new ListBag(_dict, _list);
copy.AddMembersFromObject(arg);
result = copy;
return true;
}
result = null;
return false;
}
/// <summary>
/// Provides the implementation of performing AddAssign and SubtractAssign binary operations.
/// </summary>
/// <param name="binder">The binder provided by the call site.</param>
/// <param name="handler">The handler for the operation.</param>
/// <param name="result">The result of the operation.</param>
/// <returns>true if the operation is complete, false if the call site should determine behavior.</returns>
public override bool TryBinaryOperation(BinaryOperationBinder binder, object handler, out object result) {
if (binder.Operation == ExpressionType.AddAssign) {
result = InPlaceAdd(handler);
return true;
}
if (binder.Operation == ExpressionType.SubtractAssign) {
result = InPlaceSubtract(handler);
return true;
}
result = null;
return false;
}
public override bool TryBinaryOperation( BinaryOperationBinder binder, object arg, out object result )
{
if(!ReferenceEquals(Prototype, null))
{
if(Prototype.TryBinaryOperation(binder, arg, out result))
{
return true;
}
}
if ( TryBinaryOperationMissing == null )
{
result = null;
return false;
}
return TryBinaryOperationMissing( binder, arg, out result );
}
public override bool TryBinaryOperation(BinaryOperationBinder binder, object arg, out object result)
{
var str = arg as string;
if (str != null)
{
if (binder.Operation == ExpressionType.Equal)
{
result = node.Value == str;
return true;
}
if (binder.Operation == ExpressionType.NotEqual)
{
result = node.Value != str;
return true;
}
}
return base.TryBinaryOperation(binder, arg, out result);
}
internal override bool BinaryOperation(BinaryOperationBinder binder, Any arg, out Any result)
{
var str = arg as String;
if (str != null)
{
switch (binder.Operation)
{
case ExpressionType.Add:
result = new String(Value + str.Value);
break;
default:
throw new ArgumentOutOfRangeException();
}
return true;
}
return base.BinaryOperation(binder, arg, out result);
}
public override DynamicMetaObject BindBinaryOperation(BinaryOperationBinder binder, DynamicMetaObject arg)
{
/* Effectively returns the following code:
* {
* var thisEvaled = (JsonObject)<Expression>;
* object res;
* ReturnType finalResult;
* if(!Value.InnerTryBinaryOperations(Operand, arg, ReturnType, out res))
* {
* throw new InvalidCastException("Unable to invoke dynamic binary operation [<Operation>] on ["+thisRef+"]");
* }
* finalResult = (ReturnType)res;
* }
*/
var thisRef = Expression.Type != typeof(JsonObject) ? Expression.Convert(Expression, typeof(JsonObject)) : Expression;
var thisEvaled = ThisEvaled;
var thisAssigned = Expression.Assign(thisEvaled, thisRef);
var finalResult = Expression.Variable(binder.ReturnType);
var argRef = ArgRef;
var argAssigned = Expression.Assign(argRef, (arg.RuntimeType == null || arg.RuntimeType.IsValueType()) ? Expression.Convert(arg.Expression, typeof(object)) : arg.Expression);
var res = Res;
var tryInvokeMemberCall = Expression.Call(thisEvaled, InnerTryBinaryOperation, Expression.Constant(binder.Operation), argRef, Expression.Constant(binder.ReturnType), res);
var throwExc =
Expression.Throw(
Expression.New(
InvalidCastExceptionCons,
Expression.Call(
StringConcat,
Expression.Constant("Unable to invoke dynamic binary operation [" + binder.Operation + "] on ["),
thisEvaled,
CloseSquareBracket
)
)
);
var notIf =
Expression.IfThen(
Expression.Not(tryInvokeMemberCall),
throwExc
);
var finalAssign = Expression.Assign(finalResult, Expression.Convert(res, binder.ReturnType));
var retBlock = Expression.Block(new[] { thisEvaled, finalResult, res, argRef }, thisAssigned, argAssigned, notIf, finalAssign);
var restrictions = BindingRestrictions.GetTypeRestriction(Expression, LimitType);
return new DynamicMetaObject(retBlock, restrictions);
}
/// <summary>
/// Performs the binding of the dynamic binary operation.
/// </summary>
/// <param name="binder">
/// An instance of the <see cref="BinaryOperationBinder" /> that represents the details of the dynamic
/// operation.
/// </param>
/// <param name="arg">
/// An instance of the <see cref="DynamicMetaObject" /> representing the right hand side of the binary
/// operation.
/// </param>
/// <returns>The new <see cref="DynamicMetaObject" /> representing the result of the binding.</returns>
public virtual DynamicMetaObject BindBinaryOperation(BinaryOperationBinder binder, DynamicMetaObject arg)
{
ContractUtils.RequiresNotNull(binder, nameof(binder));
return(binder.FallbackBinaryOperation(this, arg));
}
public override DynamicMetaObject BindBinaryOperation(BinaryOperationBinder binder, DynamicMetaObject arg) {
if (IsOverridden("TryBinaryOperation")) {
return CallMethodWithResult("TryBinaryOperation", binder, DynamicMetaObject.GetExpressions(new DynamicMetaObject[] {arg}), (e) => binder.FallbackBinaryOperation(this, arg, e));
}
return base.BindBinaryOperation(binder, arg);
}
public virtual new bool TryBinaryOperation(BinaryOperationBinder binder, Object arg, out Object result)
{
result = default(Object);
return default(bool);
}
public override bool TryBinaryOperation(BinaryOperationBinder binder, object arg, out object result)
{
return base.TryBinaryOperation(binder, arg, out result);
}
/// <summary>
/// Override on DynamicObject
/// </summary>
/// <param name="binder"></param>
/// <param name="arg"></param>
/// <param name="result"></param>
/// <returns></returns>
public override bool TryBinaryOperation(BinaryOperationBinder binder, object arg, out object result)
{
result = new Mimic();
return true;
}
public override DynamicMetaObject BindBinaryOperation(BinaryOperationBinder binder, DynamicMetaObject arg)
{
if (binder.Operation == ExpressionType.Equal)
{
var wrapper = this.Value as ExpressionContainer;
var valueExpr = wrapper.Expression as MemberExpression;
if (valueExpr != null)
{
var prevContainer = new ExpressionContainer(valueExpr.Expression) { IsStatic = ((PropertyInfo)valueExpr.Member).GetGetMethod(true).IsStatic };
return DoBindSetMember(prevContainer, binder.ReturnType, valueExpr.Member.Name, false, arg);
}
}
return base.BindBinaryOperation(binder, arg);
}
public virtual DynamicMetaObject BindBinaryOperation(BinaryOperationBinder binder, DynamicMetaObject arg)
{
throw new NotImplementedException();
}
public override bool TryBinaryOperation(BinaryOperationBinder binder, object arg, out object result)
{
result = MakeBinaryBuilder(Expression, binder.Operation, arg);
return true;
}
private DispatchResult DispatchBinaryOperation(BinaryOperationBinder binder, Object arg1, Object arg2)
{
var old_value = Value;
Value = arg1;
try
{
try
{
try
{
var result = BinaryOperation(binder, arg2);
if (result is FallbackException) throw (FallbackException)result;
return Succeed(result);
}
catch (FallbackException)
{
var dynamic_object = Value as IDynamicObject;
if (dynamic_object != null) return Succeed(dynamic_object.BinaryOperation(binder, arg2));
else throw;
}
}
catch (FallbackException)
{
return Fail();
}
catch (Exception ex)
{
if (WrapExceptions)
{
var bind_args = new OrderedDictionary<String, Object>();
bind_args.Add("arg1", arg1);
bind_args.Add("arg2", arg2);
throw new BindException(binder, bind_args, ex);
}
else
{
throw;
}
}
}
finally
{
Value = old_value;
}
}
public sealed override DynamicMetaObject BindBinaryOperation(BinaryOperationBinder binder, DynamicMetaObject arg)
{
var fallback = ((Func<Expression>)(() =>
{
try { return base.BindBinaryOperation(binder, arg).Expression; }
catch (Exception ex) { return Expression.Throw(Expression.Constant(ex)); }
}))();
var dispatchResult = Expression.Parameter(typeof(DispatchResult), "dispatchResult");
var shim = Expression.Block(dispatchResult.MkArray(),
// 1. var dispatchResult = DispatchBinaryOperation(binder, `expression`, arg);
Expression.Assign(dispatchResult, Expression.Call(
Expression.Constant(this),
typeof(SimpleMetaObject).GetMethod("DispatchBinaryOperation", BF.PrivateInstance),
Expression.Constant(binder),
Expression,
Expression.Convert(arg.Expression, typeof(Object)))),
// 2. return dispatchResult.Success ? dispatchResult.Result : `fallback`;
Expression.Condition(
Expression.Property(dispatchResult, "Success"),
Expression.Convert(Expression.Property(dispatchResult, "Result"), binder.ReturnType),
fallback,
binder.ReturnType));
return new DynamicMetaObject(shim, BindingRestrictions.GetTypeRestriction(Expression, LimitType));
}
public virtual Object BinaryOperation(BinaryOperationBinder binder, Object arg) { throw Fallback(); }
/// <summary>
/// Performs the binding of the dynamic binary operation.
/// </summary>
/// <param name="binder">An instance of the <see cref="BinaryOperationBinder"/> that represents the details of the dynamic operation.</param>
/// <param name="arg">An instance of the <see cref="DynamicMetaObject"/> representing the right hand side of the binary operation.</param>
/// <returns>The new <see cref="DynamicMetaObject"/> representing the result of the binding.</returns>
public virtual DynamicMetaObject BindBinaryOperation(BinaryOperationBinder binder, DynamicMetaObject arg) {
ContractUtils.RequiresNotNull(binder, "binder");
return binder.FallbackBinaryOperation(this, arg);
}
/// <summary>
/// Forwards the Binary operation
/// </summary>
/// <param name="binder"></param>
/// <param name="arg"></param>
/// <param name="result"></param>
/// <returns></returns>
public override bool TryBinaryOperation(BinaryOperationBinder binder, object arg, out object result)
{
result = null;
try
{
result = Impromptu.InvokeBinaryOperator(CallTarget, binder.Operation, arg);
return true;
}
catch (RuntimeBinderException)
{
return false;
}
}
public override DynamicMetaObject BindBinaryOperation(BinaryOperationBinder binder, DynamicMetaObject arg)
{
return scriptItem.PostProcessBindResult(metaDynamic.BindBinaryOperation(binder, arg));
}
public virtual new System.Dynamic.DynamicMetaObject BindBinaryOperation(BinaryOperationBinder binder, System.Dynamic.DynamicMetaObject arg)
{
Contract.Requires(binder != null);
return(default(System.Dynamic.DynamicMetaObject));
}
public override Boolean TryBinaryOperation(BinaryOperationBinder binder, Object arg, out Object result)
{
throw new NotImplementedException("JsStore.TryBinaryOperation");
}
public virtual new bool TryBinaryOperation(BinaryOperationBinder binder, Object arg, out Object result)
{
result = default(Object);
return(default(bool));
}
public override bool TryBinaryOperation (BinaryOperationBinder binder, object arg, out object result)
{
Console.WriteLine ("System.Windows.Interop.ComAutomationEventMetaObjectProvider.TryBinaryOperation: NIEX");
throw new NotImplementedException ();
}
public override bool TryBinaryOperation(BinaryOperationBinder binder, Object arg, out Object result)
{
IntPtr res;
if (!(arg is PyObject))
arg = arg.ToPython();
switch (binder.Operation)
{
case ExpressionType.Add:
res = Runtime.PyNumber_Add(this.obj, ((PyObject)arg).obj);
break;
case ExpressionType.AddAssign:
res = Runtime.PyNumber_InPlaceAdd(this.obj, ((PyObject)arg).obj);
break;
case ExpressionType.Subtract:
res = Runtime.PyNumber_Subtract(this.obj, ((PyObject)arg).obj);
break;
case ExpressionType.SubtractAssign:
res = Runtime.PyNumber_InPlaceSubtract(this.obj, ((PyObject)arg).obj);
break;
case ExpressionType.Multiply:
res = Runtime.PyNumber_Multiply(this.obj, ((PyObject)arg).obj);
break;
case ExpressionType.MultiplyAssign:
res = Runtime.PyNumber_InPlaceMultiply(this.obj, ((PyObject)arg).obj);
break;
case ExpressionType.Divide:
res = Runtime.PyNumber_Divide(this.obj, ((PyObject)arg).obj);
break;
case ExpressionType.DivideAssign:
res = Runtime.PyNumber_InPlaceDivide(this.obj, ((PyObject)arg).obj);
break;
case ExpressionType.And:
res = Runtime.PyNumber_And(this.obj, ((PyObject)arg).obj);
break;
case ExpressionType.AndAssign:
res = Runtime.PyNumber_InPlaceAnd(this.obj, ((PyObject)arg).obj);
break;
case ExpressionType.ExclusiveOr:
res = Runtime.PyNumber_Xor(this.obj, ((PyObject)arg).obj);
break;
case ExpressionType.ExclusiveOrAssign:
res = Runtime.PyNumber_InPlaceXor(this.obj, ((PyObject)arg).obj);
break;
case ExpressionType.GreaterThan:
result = Runtime.PyObject_Compare(this.obj, ((PyObject)arg).obj) > 0;
return true;
case ExpressionType.GreaterThanOrEqual:
result = Runtime.PyObject_Compare(this.obj, ((PyObject)arg).obj) >= 0;
return true;
case ExpressionType.LeftShift:
res = Runtime.PyNumber_Lshift(this.obj, ((PyObject)arg).obj);
break;
case ExpressionType.LeftShiftAssign:
res = Runtime.PyNumber_InPlaceLshift(this.obj, ((PyObject)arg).obj);
break;
case ExpressionType.LessThan:
result = Runtime.PyObject_Compare(this.obj, ((PyObject)arg).obj) < 0;
return true;
case ExpressionType.LessThanOrEqual:
result = Runtime.PyObject_Compare(this.obj, ((PyObject)arg).obj) <= 0;
return true;
case ExpressionType.Modulo:
res = Runtime.PyNumber_Remainder(this.obj, ((PyObject)arg).obj);
break;
case ExpressionType.ModuloAssign:
res = Runtime.PyNumber_InPlaceRemainder(this.obj, ((PyObject)arg).obj);
break;
case ExpressionType.NotEqual:
result = Runtime.PyObject_Compare(this.obj, ((PyObject)arg).obj) != 0;
return true;
case ExpressionType.Or:
res = Runtime.PyNumber_Or(this.obj, ((PyObject)arg).obj);
break;
case ExpressionType.OrAssign:
res = Runtime.PyNumber_InPlaceOr(this.obj, ((PyObject)arg).obj);
break;
case ExpressionType.Power:
res = Runtime.PyNumber_Power(this.obj, ((PyObject)arg).obj);
break;
case ExpressionType.RightShift:
res = Runtime.PyNumber_Rshift(this.obj, ((PyObject)arg).obj);
break;
case ExpressionType.RightShiftAssign:
res = Runtime.PyNumber_InPlaceRshift(this.obj, ((PyObject)arg).obj);
break;
default:
result = null;
return false;
}
result = new PyObject(res);
return true;
}
public override bool TryBinaryOperation(BinaryOperationBinder binder, object arg, out object result)
{
switch (binder.Operation)
{
case ExpressionType.Equal:
result = ReferenceEquals(arg, Nil.Instance) || (object)arg == null;
return true;
case ExpressionType.NotEqual:
result = !ReferenceEquals(arg, Nil.Instance) && (object)arg != null;
return true;
}
return base.TryBinaryOperation(binder, arg, out result);
}
public virtual bool TryBinaryOperation(BinaryOperationBinder binder, object arg, out object result) {
result = null;
return false;
}
// // Summary: // Provides implementation for binary operations. Classes derived from the System.Dynamic.DynamicObject // class can override this method to specify dynamic behavior for operations such // as addition and multiplication. // // Parameters: // binder: // Provides information about the binary operation. The binder.Operation property // returns an System.Linq.Expressions.ExpressionType object. For example, for the // sum = first + second statement, where first and second are derived from the DynamicObject // class, binder.Operation returns ExpressionType.Add. // // arg: // The right operand for the binary operation. For example, for the sum = first // + second statement, where first and second are derived from the DynamicObject // class, arg is equal to second. // // result: // The result of the binary operation. // // Returns: // true if the operation is successful; otherwise, false. If this method returns // false, the run-time binder of the language determines the behavior. (In most // cases, a language-specific run-time exception is thrown.) public virtual bool TryBinaryOperation(BinaryOperationBinder binder, object arg, out object result);
/*!*/
public override DynamicMetaObject BindBinaryOperation(BinaryOperationBinder/*!*/ binder, DynamicMetaObject/*!*/ arg)
{
return InteropBinder.BinaryOperation.Bind(CreateMetaContext(), binder, this, arg, binder.FallbackBinaryOperation);
}
public virtual bool TryBinaryOperation(BinaryOperationBinder binder, object arg, out object result)
{
result = null;
return(false);
}