class/System.Core/System.Linq.jvm/ExpressionInterpreter.cs

   1 //
   2 // ExpressionInterpreter.cs
   3 //
   4 // (C) 2008 Mainsoft, Inc. (http://www.mainsoft.com)
   5 // (C) 2008 db4objects, Inc. (http://www.db4o.com)
   6 //
   7 // Permission is hereby granted, free of charge, to any person obtaining
   8 // a copy of this software and associated documentation files (the
   9 // "Software"), to deal in the Software without restriction, including
  10 // without limitation the rights to use, copy, modify, merge, publish,
  11 // distribute, sublicense, and/or sell copies of the Software, and to
  12 // permit persons to whom the Software is furnished to do so, subject to
  13 // the following conditions:
  14 //
  15 // The above copyright notice and this permission notice shall be
  16 // included in all copies or substantial portions of the Software.
  17 //
  18 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  19 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  21 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  22 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  23 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  24 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25 //
  26
  27 using System;
  28 using System.Collections;
  29 using System.Collections.Generic;
  30 using System.Collections.ObjectModel;
  31 using System.Linq.Expressions;
  32 using System.Reflection;
  33
  34 namespace System.Linq.jvm {
  35
  36         class ExpressionInterpreter : ExpressionVisitor {
  37
  38                 LambdaExpression lambda;
  39                 object [] arguments;
  40                 Stack<object> stack = new Stack<object> ();
  41
  42                 void Push (object value)
  43                 {
  44                         stack.Push (value);
  45                 }
  46
  47                 object Pop ()
  48                 {
  49                         return stack.Pop ();
  50                 }
  51
  52                 public ExpressionInterpreter (LambdaExpression lambda, object [] arguments)
  53                 {
  54                         this.lambda = lambda;
  55                         this.arguments = arguments;
  56                 }
  57
  58                 private void VisitCoalesce (BinaryExpression binary)
  59                 {
  60                         Visit (binary.Left);
  61
  62                         var left = Pop ();
  63
  64                         if (left == null) {
  65                                 Visit (binary.Right);
  66                                 return;
  67                         }
  68
  69                         if (binary.Conversion == null) {
  70                                 Push (left);
  71                                 return;
  72                         }
  73
  74                         Push (Invoke (binary.Conversion.Compile (), new [] { left }));
  75                 }
  76
  77                 void VisitAndAlso (BinaryExpression binary)
  78                 {
  79                         object left = null;
  80                         object right = null;
  81
  82                         Visit (binary.Left);
  83
  84                         left = Pop ();
  85
  86                         if (left == null || ((bool) left)) {
  87                                 Visit (binary.Right);
  88                                 right = Pop ();
  89                         }
  90
  91                         Push (Math.And (left, right));
  92                 }
  93
  94                 void VisitUserDefinedAndAlso (BinaryExpression binary)
  95                 {
  96                         object left = null;
  97                         object right = null;
  98
  99                         Visit (binary.Left);
 100
 101                         left = Pop ();
 102
 103                         if (InvokeFalseOperator (binary, left)) {
 104                                 Push (left);
 105                                 return;
 106                         }
 107
 108                         Visit (binary.Right);
 109                         right = Pop ();
 110
 111                         if (binary.IsLiftedToNull && right == null) {
 112                                 Push (null);
 113                                 return;
 114                         }
 115
 116                         Push (InvokeMethod (binary.Method, null, new [] { left, right }));
 117                 }
 118
 119                 static bool InvokeTrueOperator (BinaryExpression binary, object target)
 120                 {
 121                         return (bool) InvokeMethod (GetTrueOperator (binary), null, new [] { target });
 122                 }
 123
 124                 static bool InvokeFalseOperator (BinaryExpression binary, object target)
 125                 {
 126                         return (bool) InvokeMethod (GetFalseOperator (binary), null, new [] { target });
 127                 }
 128
 129                 static MethodInfo GetFalseOperator (BinaryExpression binary)
 130                 {
 131                         return Expression.GetFalseOperator (binary.Left.Type.GetNotNullableType ());
 132                 }
 133
 134                 static MethodInfo GetTrueOperator (BinaryExpression binary)
 135                 {
 136                         return Expression.GetTrueOperator (binary.Left.Type.GetNotNullableType ());
 137                 }
 138
 139                 void VisitOrElse (BinaryExpression binary)
 140                 {
 141                         object left = null;
 142                         object right = null;
 143
 144                         Visit (binary.Left);
 145                         left = Pop ();
 146
 147                         if (left == null || !((bool) left)) {
 148                                 Visit (binary.Right);
 149                                 right = Pop ();
 150                         }
 151
 152                         Push (Math.Or (left, right));
 153                 }
 154
 155                 void VisitUserDefinedOrElse (BinaryExpression binary)
 156                 {
 157                         object left = null;
 158                         object right = null;
 159
 160                         Visit (binary.Left);
 161                         left = Pop ();
 162
 163                         if (InvokeTrueOperator (binary, left)) {
 164                                 Push (left);
 165                                 return;
 166                         }
 167
 168                         Visit (binary.Right);
 169                         right = Pop ();
 170
 171                         if (binary.IsLiftedToNull && right == null) {
 172                                 Push (null);
 173                                 return;
 174                         }
 175
 176                         Push (InvokeMethod (binary.Method, null, new [] { left, right }));
 177                 }
 178
 179                 void VisitLogicalBinary (BinaryExpression binary)
 180                 {
 181                         Visit (binary.Left);
 182                         Visit (binary.Right);
 183
 184                         var right = Pop ();
 185                         var left = Pop ();
 186
 187                         Push (Math.Evaluate (left, right, binary.Type, binary.NodeType));
 188                 }
 189
 190                 void VisitArithmeticBinary (BinaryExpression binary)
 191                 {
 192                         Visit (binary.Left);
 193                         Visit (binary.Right);
 194
 195                         if (IsNullBinaryLifting (binary))
 196                                 return;
 197
 198                         var right = Pop ();
 199                         var left = Pop ();
 200
 201                         switch (binary.NodeType) {
 202                         case ExpressionType.RightShift:
 203                                 Push (Math.RightShift (left, Convert.ToInt32 (right), Type.GetTypeCode (binary.Type.GetNotNullableType ())));
 204                                 return;
 205                         case ExpressionType.LeftShift:
 206                                 Push (Math.LeftShift (left, Convert.ToInt32 (right), Type.GetTypeCode (binary.Type.GetNotNullableType ())));
 207                                 return;
 208                         default:
 209                                 Push (Math.Evaluate (left, right, binary.Type, binary.NodeType));
 210                                 break;
 211                         }
 212                 }
 213
 214                 bool IsNullRelationalBinaryLifting (BinaryExpression binary)
 215                 {
 216                         var right = Pop ();
 217                         var left = Pop ();
 218
 219                         if (binary.IsLifted && (left == null || right == null)) {
 220                                 if (binary.IsLiftedToNull) {
 221                                         Push (null);
 222                                         return true;
 223                                 }
 224
 225                                 switch (binary.NodeType) {
 226                                 case ExpressionType.Equal:
 227                                         Push (BinaryEqual (binary, left, right));
 228                                         break;
 229                                 case ExpressionType.NotEqual:
 230                                         Push (BinaryNotEqual (binary, left, right));
 231                                         break;
 232                                 default:
 233                                         Push (false);
 234                                         break;
 235                                 }
 236
 237                                 return true;
 238                         }
 239
 240                         Push (left);
 241                         Push (right);
 242
 243                         return false;
 244                 }
 245
 246                 void VisitRelationalBinary (BinaryExpression binary)
 247                 {
 248                         Visit (binary.Left);
 249                         Visit (binary.Right);
 250
 251                         if (IsNullRelationalBinaryLifting (binary))
 252                                 return;
 253
 254                         var right = Pop ();
 255                         var left = Pop ();
 256
 257                         switch (binary.NodeType) {
 258                         case ExpressionType.Equal:
 259                                 Push (BinaryEqual (binary, left, right));
 260                                 return;
 261                         case ExpressionType.NotEqual:
 262                                 Push (BinaryNotEqual (binary, left, right));
 263                                 return;
 264                         case ExpressionType.LessThan:
 265                                 Push (Comparer.Default.Compare (left, right) < 0);
 266                                 return;
 267                         case ExpressionType.LessThanOrEqual:
 268                                 Push (Comparer.Default.Compare (left, right) <= 0);
 269                                 return;
 270                         case ExpressionType.GreaterThan:
 271                                 Push (Comparer.Default.Compare (left, right) > 0);
 272                                 return;
 273                         case ExpressionType.GreaterThanOrEqual:
 274                                 Push (Comparer.Default.Compare (left, right) >= 0);
 275                                 return;
 276                         }
 277                 }
 278
 279                 void VisitLogicalShortCircuitBinary (BinaryExpression binary)
 280                 {
 281                         switch (binary.NodeType) {
 282                         case ExpressionType.AndAlso:
 283                                 VisitAndAlso (binary);
 284                                 return;
 285                         case ExpressionType.OrElse:
 286                                 VisitOrElse (binary);
 287                                 return;
 288                         }
 289                 }
 290
 291                 void VisitArrayIndex (BinaryExpression binary)
 292                 {
 293                         Visit (binary.Left);
 294                         var left = Pop ();
 295                         Visit (binary.Right);
 296                         var right = Pop ();
 297
 298                         Push (((Array) left).GetValue ((int) right));
 299                 }
 300
 301                 bool IsNullBinaryLifting (BinaryExpression binary)
 302                 {
 303                         var right = Pop ();
 304                         var left = Pop ();
 305
 306                         if (binary.IsLifted && (right == null || left == null)) {
 307                                 if (binary.IsLiftedToNull)
 308                                         Push (null);
 309                                 else
 310                                         Push (GetDefaultValue (binary.Type));
 311
 312                                 return true;
 313                         }
 314
 315                         Push (left);
 316                         Push (right);
 317
 318                         return false;
 319                 }
 320
 321                 static object GetDefaultValue (Type type)
 322                 {
 323                         var array = (Array) Array.CreateInstance (type, 1);
 324                         return array.GetValue (0);
 325                 }
 326
 327                 void VisitUserDefinedBinary (BinaryExpression binary)
 328                 {
 329                         switch (binary.NodeType) {
 330                         case ExpressionType.AndAlso:
 331                         case ExpressionType.OrElse:
 332                                 VisitUserDefinedLogicalShortCircuitBinary (binary);
 333                                 return;
 334                         case ExpressionType.Equal:
 335                         case ExpressionType.NotEqual:
 336                                 VisitUserDefinedRelationalBinary (binary);
 337                                 return;
 338                         default:
 339                                 VisitUserDefinedCommonBinary (binary);
 340                                 return;
 341                         }
 342                 }
 343
 344                 void VisitUserDefinedLogicalShortCircuitBinary (BinaryExpression binary)
 345                 {
 346                         switch (binary.NodeType) {
 347                         case ExpressionType.AndAlso:
 348                                 VisitUserDefinedAndAlso (binary);
 349                                 return;
 350                         case ExpressionType.OrElse:
 351                                 VisitUserDefinedOrElse (binary);
 352                                 return;
 353                         }
 354                 }
 355
 356                 void VisitUserDefinedRelationalBinary (BinaryExpression binary)
 357                 {
 358                         Visit (binary.Left);
 359                         Visit (binary.Right);
 360
 361                         if (IsNullRelationalBinaryLifting (binary))
 362                                 return;
 363
 364                         var right = Pop ();
 365                         var left = Pop ();
 366
 367                         Push (InvokeBinary (binary, left, right));
 368                 }
 369
 370                 void VisitUserDefinedCommonBinary (BinaryExpression binary)
 371                 {
 372                         Visit (binary.Left);
 373                         Visit (binary.Right);
 374
 375                         if (IsNullBinaryLifting (binary))
 376                                 return;
 377
 378                         var right = Pop ();
 379                         var left = Pop ();
 380
 381                         Push (InvokeBinary (binary, left, right));
 382                 }
 383
 384                 object InvokeBinary (BinaryExpression binary, object left, object right)
 385                 {
 386                         return InvokeMethod (binary.Method, null, new [] { left, right });
 387                 }
 388
 389                 bool BinaryEqual (BinaryExpression binary, object left, object right)
 390                 {
 391                         if (typeof (ValueType).IsAssignableFrom (binary.Right.Type))
 392                                 return ValueType.Equals (left, right);
 393                         else
 394                                 return left == right;
 395                 }
 396
 397                 bool BinaryNotEqual (BinaryExpression binary, object left, object right)
 398                 {
 399                         if (typeof (ValueType).IsAssignableFrom (binary.Right.Type))
 400                                 return !ValueType.Equals (left, right);
 401                         else
 402                                 return left != right;
 403                 }
 404
 405                 protected override void VisitBinary (BinaryExpression binary)
 406                 {
 407                         if (binary.Method != null) {
 408                                 VisitUserDefinedBinary (binary);
 409                                 return;
 410                         }
 411
 412                         switch (binary.NodeType) {
 413                         case ExpressionType.ArrayIndex:
 414                                 VisitArrayIndex (binary);
 415                                 return;
 416                         case ExpressionType.Coalesce:
 417                                 VisitCoalesce (binary);
 418                                 return;
 419                         case ExpressionType.AndAlso:
 420                         case ExpressionType.OrElse:
 421                                 VisitLogicalShortCircuitBinary (binary);
 422                                 return;
 423                         case ExpressionType.Equal:
 424                         case ExpressionType.NotEqual:
 425                         case ExpressionType.GreaterThan:
 426                         case ExpressionType.GreaterThanOrEqual:
 427                         case ExpressionType.LessThan:
 428                         case ExpressionType.LessThanOrEqual:
 429                                 VisitRelationalBinary (binary);
 430                                 return;
 431                         case ExpressionType.And:
 432                         case ExpressionType.Or:
 433                                 VisitLogicalBinary (binary);
 434                                 return;
 435                         case ExpressionType.Power:
 436                         case ExpressionType.Add:
 437                         case ExpressionType.AddChecked:
 438                         case ExpressionType.Divide:
 439                         case ExpressionType.ExclusiveOr:
 440                         case ExpressionType.LeftShift:
 441                         case ExpressionType.Modulo:
 442                         case ExpressionType.Multiply:
 443                         case ExpressionType.MultiplyChecked:
 444                         case ExpressionType.RightShift:
 445                         case ExpressionType.Subtract:
 446                         case ExpressionType.SubtractChecked:
 447                                 VisitArithmeticBinary (binary);
 448                                 return;
 449                         }
 450                 }
 451
 452                 void VisitTypeAs (UnaryExpression unary)
 453                 {
 454                         Visit (unary.Operand);
 455
 456                         var value = Pop ();
 457                         if (value == null || !Math.IsType (unary.Type, value))
 458                                 Push (null);
 459                         else
 460                                 Push (value);
 461                 }
 462
 463                 void VisitArrayLength (UnaryExpression unary)
 464                 {
 465                         Visit (unary.Operand);
 466
 467                         var array = (Array) Pop ();
 468                         Push (array.Length);
 469                 }
 470
 471                 void VisitConvert (UnaryExpression unary)
 472                 {
 473                         if (unary.NodeType == ExpressionType.ConvertChecked)
 474                                 VisitConvertChecked (unary);
 475                         else
 476                                 VisitConvertUnchecked (unary);
 477                 }
 478
 479                 void VisitConvertChecked (UnaryExpression unary)
 480                 {
 481                         VisitConvert (unary, Math.ConvertToTypeChecked);
 482                 }
 483
 484                 void VisitConvertUnchecked (UnaryExpression unary)
 485                 {
 486                         VisitConvert (unary, Math.ConvertToTypeUnchecked);
 487                 }
 488
 489                 void VisitConvert (UnaryExpression unary, Func<object, Type, Type, object> converter)
 490                 {
 491                         Visit (unary.Operand);
 492                         Push (converter (Pop (), unary.Operand.Type, unary.Type));
 493                 }
 494
 495                 bool IsNullUnaryLifting (UnaryExpression unary)
 496                 {
 497                         var value = Pop ();
 498
 499                         if (unary.IsLifted && value == null) {
 500                                 if (unary.IsLiftedToNull) {
 501                                         Push (null);
 502                                         return true;
 503                                 } else {
 504                                         throw new InvalidOperationException ();
 505                                 }
 506                         }
 507
 508                         Push (value);
 509                         return false;
 510                 }
 511
 512                 void VisitQuote (UnaryExpression unary)
 513                 {
 514                         Push (unary.Operand);
 515                 }
 516
 517                 void VisitUserDefinedUnary (UnaryExpression unary)
 518                 {
 519                         Visit (unary.Operand);
 520
 521                         if (IsNullUnaryLifting (unary))
 522                                 return;
 523
 524                         var value = Pop ();
 525
 526                         Push (InvokeUnary (unary, value));
 527                 }
 528
 529                 object InvokeUnary (UnaryExpression unary, object value)
 530                 {
 531                         return InvokeMethod (unary.Method, null, new [] { value });
 532                 }
 533
 534                 void VisitArithmeticUnary (UnaryExpression unary)
 535                 {
 536                         Visit (unary.Operand);
 537
 538                         if (IsNullUnaryLifting (unary))
 539                                 return;
 540
 541                         var value = Pop ();
 542
 543                         switch (unary.NodeType) {
 544                         case ExpressionType.Not:
 545                                 if (unary.Type.GetNotNullableType () == typeof (bool))
 546                                         Push (!Convert.ToBoolean (value));
 547                                 else
 548                                         Push (~Convert.ToInt32 (value));
 549                                 return;
 550                         case ExpressionType.Negate:
 551                                 Push (Math.Negate (value, Type.GetTypeCode (unary.Type.GetNotNullableType ())));
 552                                 return;
 553                         case ExpressionType.NegateChecked:
 554                                 Push (Math.NegateChecked (value, Type.GetTypeCode (unary.Type.GetNotNullableType ())));
 555                                 return;
 556                         case ExpressionType.UnaryPlus:
 557                                 Push (value);
 558                                 return;
 559                         }
 560                 }
 561
 562                 protected override void VisitUnary (UnaryExpression unary)
 563                 {
 564                         if (unary.Method != null) {
 565                                 VisitUserDefinedUnary (unary);
 566                                 return;
 567                         }
 568
 569                         switch (unary.NodeType) {
 570                         case ExpressionType.Quote:
 571                                 VisitQuote (unary);
 572                                 return;
 573                         case ExpressionType.TypeAs:
 574                                 VisitTypeAs (unary);
 575                                 return;
 576                         case ExpressionType.ArrayLength:
 577                                 VisitArrayLength (unary);
 578                                 return;
 579                         case ExpressionType.Convert:
 580                         case ExpressionType.ConvertChecked:
 581                                 VisitConvert (unary);
 582                                 return;
 583                         case ExpressionType.Negate:
 584                         case ExpressionType.NegateChecked:
 585                         case ExpressionType.Not:
 586                         case ExpressionType.UnaryPlus:
 587                                 VisitArithmeticUnary (unary);
 588                                 return;
 589                         default:
 590                                 throw new NotImplementedException (unary.NodeType.ToString ());
 591                         }
 592                 }
 593
 594                 protected override void VisitNew (NewExpression nex)
 595                 {
 596                         if (nex.Constructor == null)
 597                                 Push (Activator.CreateInstance (nex.Type));
 598                         else
 599                                 Push (InvokeConstructor (nex.Constructor, VisitListExpressions (nex.Arguments)));
 600                 }
 601
 602                 static object InvokeConstructor (ConstructorInfo constructor, object [] arguments)
 603                 {
 604                         try {
 605                                 return constructor.Invoke (arguments);
 606                         } catch (TargetInvocationException e) {
 607                                 throw e.InnerException;
 608                         }
 609                 }
 610
 611                 protected override void VisitTypeIs (TypeBinaryExpression type)
 612                 {
 613                         Visit (type.Expression);
 614                         Push (Math.IsType (type.TypeOperand, Pop ()));
 615                 }
 616
 617                 void VisitMemberInfo (MemberInfo mi)
 618                 {
 619                         mi.OnFieldOrProperty (
 620                                 field => {
 621                                         object target = null;
 622                                         if (!field.IsStatic)
 623                                                 target = Pop ();
 624
 625                                         Push (field.GetValue (target));
 626                                 },
 627                                 property => {
 628                                         object target = null;
 629                                         var getter = property.GetGetMethod (true);
 630                                         if (!getter.IsStatic)
 631                                                 target = Pop ();
 632
 633                                         Push (property.GetValue (target, null));
 634                                 });
 635                 }
 636
 637                 protected override void VisitMemberAccess (MemberExpression member)
 638                 {
 639                         Visit (member.Expression);
 640                         VisitMemberInfo (member.Member);
 641                 }
 642
 643                 protected override void VisitNewArray (NewArrayExpression newArray)
 644                 {
 645                         switch (newArray.NodeType) {
 646                         case ExpressionType.NewArrayInit:
 647                                 VisitNewArrayInit (newArray);
 648                                 return;
 649                         case ExpressionType.NewArrayBounds:
 650                                 VisitNewArrayBounds (newArray);
 651                                 return;
 652                         }
 653
 654                         throw new NotSupportedException ();
 655                 }
 656
 657                 void VisitNewArrayBounds (NewArrayExpression newArray)
 658                 {
 659                         var lengths = new int [newArray.Expressions.Count];
 660                         for (int i = 0; i < lengths.Length; i++) {
 661                                 Visit (newArray.Expressions [i]);
 662                                 lengths [i] = (int) Pop ();
 663                         }
 664
 665                         Push (Array.CreateInstance (newArray.Type.GetElementType (), lengths));
 666                 }
 667
 668                 void VisitNewArrayInit (NewArrayExpression newArray)
 669                 {
 670                         var array = Array.CreateInstance (
 671                                 newArray.Type.GetElementType (),
 672                                 newArray.Expressions.Count);
 673
 674                         for (int i = 0; i < array.Length; i++) {
 675                                 Visit (newArray.Expressions [i]);
 676                                 array.SetValue (Pop (), i);
 677                         }
 678
 679                         Push (array);
 680                 }
 681
 682                 protected override void VisitConditional (ConditionalExpression conditional)
 683                 {
 684                         Visit (conditional.Test);
 685
 686                         if ((bool) Pop ())
 687                                 Visit (conditional.IfTrue);
 688                         else
 689                                 Visit (conditional.IfFalse);
 690                 }
 691
 692                 protected override void VisitMethodCall (MethodCallExpression call)
 693                 {
 694                         object instance = null;
 695                         if (call.Object != null) {
 696                                 Visit (call.Object);
 697                                 instance = Pop ();
 698                         }
 699
 700                         Push (InvokeMethod (call.Method, instance, VisitListExpressions (call.Arguments)));
 701                 }
 702
 703                 protected override void VisitParameter (ParameterExpression parameter)
 704                 {
 705                         for (int i = 0; i < lambda.Parameters.Count; i++) {
 706                                 if (lambda.Parameters [i] != parameter)
 707                                         continue;
 708
 709                                 Push (arguments [i]);
 710                                 return;
 711                         }
 712
 713                         throw new ArgumentException ();
 714                 }
 715
 716                 protected override void VisitConstant (ConstantExpression constant)
 717                 {
 718                         Push (constant.Value);
 719                 }
 720
 721                 protected override void VisitInvocation (InvocationExpression invocation)
 722                 {
 723                         Visit (invocation.Expression);
 724                         Push (Invoke ((Delegate) Pop (), VisitListExpressions (invocation.Arguments)));
 725                 }
 726
 727                 static object Invoke (Delegate dlg, object [] arguments)
 728                 {
 729                         return InvokeMethod (dlg.Method, dlg.Target, arguments);
 730                 }
 731
 732                 static object InvokeMethod (MethodBase method, object obj, object [] arguments)
 733                 {
 734                         try {
 735                                 return method.Invoke (obj, arguments);
 736                         } catch (TargetInvocationException e) {
 737                                 throw e.InnerException;
 738                         }
 739                 }
 740
 741                 protected override void VisitMemberListBinding (MemberListBinding binding)
 742                 {
 743                         var value = Pop ();
 744                         Push (value);
 745                         VisitMemberInfo (binding.Member);
 746                         VisitElementInitializerList (binding.Initializers);
 747                         Pop (); // pop the member
 748                         Push (value); // push the original target
 749                 }
 750
 751                 protected override void VisitElementInitializer (ElementInit initializer)
 752                 {
 753                         object target = null;
 754                         if (!initializer.AddMethod.IsStatic)
 755                                 target = Pop ();
 756
 757                         var arguments = VisitListExpressions (initializer.Arguments);
 758                         InvokeMethod (initializer.AddMethod, target, arguments);
 759
 760                         if (!initializer.AddMethod.IsStatic)
 761                                 Push (target);
 762                 }
 763
 764                 protected override void VisitMemberMemberBinding (MemberMemberBinding binding)
 765                 {
 766                         var value = Pop ();
 767                         Push (value);
 768                         VisitMemberInfo (binding.Member);
 769                         VisitBindingList (binding.Bindings);
 770                         Pop ();
 771                         Push (value);
 772                 }
 773
 774                 protected override void VisitMemberAssignment (MemberAssignment assignment)
 775                 {
 776                         Visit (assignment.Expression);
 777
 778                         var value = Pop ();
 779
 780                         assignment.Member.OnFieldOrProperty (
 781                                 field => {
 782                                         object target = null;
 783                                         if (!field.IsStatic)
 784                                                 target = Pop ();
 785
 786                                         field.SetValue (target, value);
 787
 788                                         if (!field.IsStatic)
 789                                                 Push (target);
 790                                 },
 791                                 property => {
 792                                         object target = null;
 793                                         var getter = property.GetGetMethod (true);
 794                                         if (!getter.IsStatic)
 795                                                 target = Pop ();
 796
 797                                         property.SetValue (target, value, null);
 798
 799                                         if (!getter.IsStatic)
 800                                                 Push (target);
 801                                 });
 802                 }
 803
 804                 protected override void VisitLambda (LambdaExpression lambda)
 805                 {
 806                         Push (lambda.Compile ());
 807                 }
 808
 809                 private object [] VisitListExpressions (ReadOnlyCollection<Expression> collection)
 810                 {
 811                         object [] results = new object [collection.Count];
 812                         for (int i = 0; i < results.Length; i++) {
 813                                 Visit (collection [i]);
 814                                 results [i] = Pop ();
 815                         }
 816
 817                         return results;
 818                 }
 819
 820                 public static object Interpret (LambdaExpression lambda, object [] arguments)
 821                 {
 822                         var interpreter = new ExpressionInterpreter (lambda, arguments);
 823                         interpreter.Visit (lambda.Body);
 824
 825                         if (lambda.GetReturnType () != typeof (void))
 826                                 return interpreter.Pop ();
 827
 828                         return null;
 829                 }
 830         }
 831 }