src/Boo.Lang/Runtime/MethodDispatcherEmitter.cs

   1 #region license
   2 // Copyright (c) 2004, 2007 Rodrigo B. de Oliveira (rbo@acm.org)
   3 // All rights reserved.
   4 //
   5 // Redistribution and use in source and binary forms, with or without modification,
   6 // are permitted provided that the following conditions are met:
   7 //
   8 //       * Redistributions of source code must retain the above copyright notice,
   9 //       this list of conditions and the following disclaimer.
  10 //       * Redistributions in binary form must reproduce the above copyright notice,
  11 //       this list of conditions and the following disclaimer in the documentation
  12 //       and/or other materials provided with the distribution.
  13 //       * Neither the name of Rodrigo B. de Oliveira nor the names of its
  14 //       contributors may be used to endorse or promote products derived from this
  15 //       software without specific prior written permission.
  16 //
  17 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  18 // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19 // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20 // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
  21 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  23 // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  24 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  25 // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26 // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27 #endregion
  28
  29 using System;
  30 using System.Reflection;
  31 using System.Reflection.Emit;
  32
  33 namespace Boo.Lang.Runtime
  34 {
  35         public delegate object Dispatcher(object target, object[] args);
  36
  37         public class MethodDispatcherEmitter : DispatcherEmitter
  38         {
  39                 protected readonly CandidateMethod _found;
  40                 protected readonly Type[] _argumentTypes;
  41
  42                 public MethodDispatcherEmitter(CandidateMethod found, params  Type[] argumentTypes) : this(found.Method.DeclaringType, found, argumentTypes)
  43                 {
  44                 }
  45
  46                 public MethodDispatcherEmitter(Type owner, CandidateMethod found, Type[] argumentTypes) : base(owner, found.Method.Name + "$" + Builtins.join(argumentTypes, "$"))
  47                 {
  48                         _found = found;
  49                         _argumentTypes = argumentTypes;
  50                 }
  51
  52                 protected override void EmitMethodBody()
  53                 {
  54                         EmitInvocation();
  55                         EmitMethodReturn();
  56                 }
  57
  58                 protected void EmitInvocation()
  59                 {
  60                         EmitLoadTargetObject();
  61                         EmitMethodArguments();
  62                         EmitMethodCall();
  63                 }
  64
  65                 protected void EmitMethodCall()
  66                 {
  67                         _il.Emit(_found.Method.IsStatic ? OpCodes.Call : OpCodes.Callvirt, _found.Method);
  68                 }
  69
  70                 protected void EmitMethodArguments()
  71                 {
  72                         EmitFixedMethodArguments();
  73                         if (_found.VarArgs) EmitVarArgsMethodArguments();
  74                 }
  75
  76                 private void EmitFixedMethodArguments()
  77                 {
  78                         int offset = FixedArgumentOffset;
  79                         int count = MinimumArgumentCount();
  80                         for (int i = 0; i < count; ++i)
  81                         {
  82                                 Type paramType = _found.GetParameterType(i + offset);
  83                                 EmitMethodArgument(i, paramType);
  84                         }
  85                 }
  86
  87                 protected virtual int FixedArgumentOffset
  88                 {
  89                         get { return 0; }
  90                 }
  91
  92                 private void EmitVarArgsMethodArguments()
  93                 {
  94                         int varArgCount = _argumentTypes.Length - MinimumArgumentCount();
  95                         Type varArgType = _found.VarArgsParameterType;
  96                         OpCode storeOpCode = GetStoreElementOpCode(varArgType);
  97                         _il.Emit(OpCodes.Ldc_I4, varArgCount);
  98                         _il.Emit(OpCodes.Newarr, varArgType);
  99                         for (int i = 0; i < varArgCount; ++i)
 100                         {
 101                                 Dup();
 102                                 _il.Emit(OpCodes.Ldc_I4, i);
 103                                 if (IsStobj(storeOpCode))
 104                                 {
 105                                         _il.Emit(OpCodes.Ldelema, varArgType);
 106                                         EmitMethodArgument(MinimumArgumentCount() + i, varArgType);
 107                                         _il.Emit(storeOpCode, varArgType);
 108                                 }
 109                                 else
 110                                 {
 111                                         EmitMethodArgument(MinimumArgumentCount() + i, varArgType);
 112                                         _il.Emit(storeOpCode);
 113                                 }
 114                         }
 115                 }
 116
 117                 private int MinimumArgumentCount()
 118                 {
 119                         return _found.MinimumArgumentCount - FixedArgumentOffset;
 120                 }
 121
 122                 static OpCode GetStoreElementOpCode(Type type)
 123                 {
 124                         if (type.IsValueType)
 125                         {
 126                                 if (type.IsEnum) return OpCodes.Stelem_I4;
 127
 128                                 switch (Type.GetTypeCode(type))
 129                                 {
 130                                         case TypeCode.Byte:
 131                                                 return OpCodes.Stelem_I1;
 132                                         case TypeCode.Int16:
 133                                                 return OpCodes.Stelem_I2;
 134                                         case TypeCode.Int32:
 135                                                 return OpCodes.Stelem_I4;
 136                                         case TypeCode.Int64:
 137                                                 return OpCodes.Stelem_I8;
 138                                         case TypeCode.Single:
 139                                                 return OpCodes.Stelem_R4;
 140                                         case TypeCode.Double:
 141                                                 return OpCodes.Stelem_R8;
 142                                 }
 143                                 return OpCodes.Stobj;
 144                         }
 145                         return OpCodes.Stelem_Ref;
 146                 }
 147
 148                 protected void EmitMethodArgument(int argumentIndex, Type expectedType)
 149                 {
 150                         EmitArgArrayElement(argumentIndex);
 151                         EmitCoercion(argumentIndex, expectedType, _found.ArgumentScores[argumentIndex]);
 152                 }
 153
 154                 private void EmitCoercion(int argumentIndex, Type expectedType, int score)
 155                 {
 156                         EmitCoercion(_argumentTypes[argumentIndex], expectedType, score);
 157                 }
 158
 159                 protected virtual void EmitLoadTargetObject()
 160                 {
 161                         if (_found.Method.IsStatic) return;
 162                         EmitLoadTargetObject(_found.Method.DeclaringType);
 163                 }
 164
 165                 private void EmitMethodReturn()
 166                 {
 167                         EmitReturn(_found.Method.ReturnType);
 168                 }
 169         }
 170 }