Tools/Castle.DynamicProxy2/Castle.DynamicProxy/Generators/Emitters/SimpleAST/ConvertExpression.cs

   1 // Copyright 2004-2007 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST
  16 {
  17         using System;
  18         using System.Reflection.Emit;
  19
  20         public class ConvertExpression : Expression
  21         {
  22                 private readonly Expression right;
  23                 private Type fromType;
  24                 private Type target;
  25
  26                 public ConvertExpression(Type targetType, Expression right)
  27                         : this(targetType, typeof(object), right)
  28                 {
  29                 }
  30
  31                 public ConvertExpression(Type targetType, Type fromType, Expression right)
  32                 {
  33                         target = targetType;
  34                         this.fromType = fromType;
  35                         this.right = right;
  36                 }
  37
  38                 public override void Emit(IMemberEmitter member, ILGenerator gen)
  39                 {
  40                         right.Emit(member, gen);
  41
  42                         if (fromType == target)
  43                         {
  44                                 return;
  45                         }
  46
  47                         if (fromType.IsByRef)
  48                         {
  49                                 fromType = fromType.GetElementType();
  50                         }
  51
  52                         if (target.IsByRef)
  53                         {
  54                                 target = target.GetElementType();
  55                         }
  56
  57                         if (target.IsValueType)
  58                         {
  59                                 if (fromType.IsValueType)
  60                                 {
  61                                         throw new NotImplementedException("Cannot convert between distinct value types");
  62                                 }
  63                                 else
  64                                 {
  65                                         // Unbox conversion
  66                                         // Assumes fromType is a boxed value
  67                                         // if we can, we emit a box and ldind, otherwise, we will use unbox.any
  68                                         if (LdindOpCodesDictionary.Instance[target] != LdindOpCodesDictionary.EmptyOpCode)
  69                                         {
  70                                                 gen.Emit(OpCodes.Unbox, target);
  71                                                 OpCodeUtil.EmitLoadIndirectOpCodeForType(gen, target);
  72                                         }
  73                                         else
  74                                         {
  75                                                 gen.Emit(OpCodes.Unbox_Any, target);
  76                                         }
  77                                 }
  78                         }
  79                         else
  80                         {
  81                                 if (fromType.IsValueType)
  82                                 {
  83                                         // Box conversion
  84                                         gen.Emit(OpCodes.Box, fromType);
  85                                         EmitCastIfNeeded(typeof(object), target, gen);
  86                                 }
  87                                 else
  88                                 {
  89                                         // Possible down-cast
  90                                         EmitCastIfNeeded(fromType, target, gen);
  91                                 }
  92                         }
  93                 }
  94
  95                 private static void EmitCastIfNeeded(Type from, Type target, ILGenerator gen)
  96                 {
  97                         if (target.IsGenericParameter)
  98                         {
  99                                 gen.Emit(OpCodes.Unbox_Any, target);
 100                         }
 101                         else if (from.IsGenericParameter)
 102                         {
 103                                 gen.Emit(OpCodes.Box, from);
 104                         }
 105                         else if (target.IsGenericType && target != from)
 106                         {
 107                                 gen.Emit(OpCodes.Castclass, target);
 108                         }
 109                         else if (target.IsSubclassOf(from))
 110                         {
 111                                 gen.Emit(OpCodes.Castclass, target);
 112                         }
 113                 }
 114         }
 115 }