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

   1 //
   2 // Interpreter.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.Linq;
  29 using System.Linq.Expressions;
  30 using System.Reflection;
  31
  32 namespace System.Linq.jvm {
  33
  34         class Interpreter {
  35
  36                 class VoidTypeMarker {
  37                 }
  38
  39                 static readonly Type VoidMarker = typeof (VoidTypeMarker);
  40                 static readonly MethodInfo [] delegates = new MethodInfo [5];
  41
  42                 LambdaExpression lambda;
  43
  44                 static Interpreter ()
  45                 {
  46                         var methods = from method in typeof (Interpreter).GetMethods (
  47                                                           BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance)
  48                                                   where method.Name == "GetDelegate"
  49                                                   select method;
  50
  51                         foreach (var method in methods)
  52                                 delegates [method.GetGenericArguments ().Length - 1] = method;
  53                 }
  54
  55                 public Interpreter (LambdaExpression lambda)
  56                 {
  57                         this.lambda = lambda;
  58                 }
  59
  60                 public Delegate CreateDelegate ()
  61                 {
  62                         var types = GetGenericSignature ();
  63                         var creator = delegates [types.Length - 1].MakeGenericMethod (types);
  64
  65                         return (Delegate) creator.Invoke (this, new object [0]);
  66                 }
  67
  68                 public void Validate ()
  69                 {
  70                         new ExpressionValidator (lambda).Validate ();
  71                 }
  72
  73                 Type [] GetGenericSignature ()
  74                 {
  75                         var count = lambda.Parameters.Count;
  76                         var types = new Type [count + 1];
  77
  78                         var return_type = lambda.GetReturnType ();
  79                         if (return_type == typeof (void))
  80                                 return_type = VoidMarker;
  81
  82                         types [count] = return_type;
  83                         for (int i = 0; i < count; i++) {
  84                                 types [i] = lambda.Parameters [i].Type;
  85                         }
  86
  87                         return types;
  88                 }
  89
  90                 object Run (object [] arg)
  91                 {
  92                         return ExpressionInterpreter.Interpret (lambda, arg);
  93                 }
  94
  95                 Delegate GetDelegate<TResult> ()
  96                 {
  97                         if (typeof (TResult) == VoidMarker)
  98                                 return new Action (ActionRunner);
  99
 100                         return new Func<TResult> (FuncRunner<TResult>);
 101                 }
 102
 103                 TResult FuncRunner<TResult> ()
 104                 {
 105                         return (TResult) Run (new object [0]);
 106                 }
 107
 108                 void ActionRunner ()
 109                 {
 110                         Run (new object [0]);
 111                 }
 112
 113                 Delegate GetDelegate<T, TResult> ()
 114                 {
 115                         if (typeof (TResult) == VoidMarker)
 116                                 return new Action<T> (ActionRunner<T>);
 117
 118                         return new Func<T, TResult> (FuncRunner<T, TResult>);
 119                 }
 120
 121                 TResult FuncRunner<T, TResult> (T arg)
 122                 {
 123                         return (TResult) Run (new object [] { arg });
 124                 }
 125
 126                 void ActionRunner<T> (T arg)
 127                 {
 128                         Run (new object [] { arg });
 129                 }
 130
 131                 Delegate GetDelegate<T1, T2, TResult> ()
 132                 {
 133                         if (typeof (TResult) == VoidMarker)
 134                                 return new Action<T1, T2> (ActionRunner<T1, T2>);
 135
 136                         return new Func<T1, T2, TResult> (FuncRunner<T1, T2, TResult>);
 137                 }
 138
 139                 TResult FuncRunner<T1, T2, TResult> (T1 arg1, T2 arg2)
 140                 {
 141                         return (TResult) Run (new object [] { arg1, arg2 });
 142                 }
 143
 144                 void ActionRunner<T1, T2> (T1 arg1, T2 arg2)
 145                 {
 146                         Run (new object [] { arg1, arg2 });
 147                 }
 148
 149                 Delegate GetDelegate<T1, T2, T3, TResult> ()
 150                 {
 151                         if (typeof (TResult) == VoidMarker)
 152                                 return new Action<T1, T2, T3> (ActionRunner<T1, T2, T3>);
 153
 154                         return new Func<T1, T2, T3, TResult> (FuncRunner<T1, T2, T3, TResult>);
 155                 }
 156
 157                 TResult FuncRunner<T1, T2, T3, TResult> (T1 arg1, T2 arg2, T3 arg3)
 158                 {
 159                         return (TResult) Run (new object [] { arg1, arg2, arg3 });
 160                 }
 161
 162                 void ActionRunner<T1, T2, T3> (T1 arg1, T2 arg2, T3 arg3)
 163                 {
 164                         Run (new object [] { arg1, arg2, arg3 });
 165                 }
 166
 167                 Delegate GetDelegate<T1, T2, T3, T4, TResult> ()
 168                 {
 169                         if (typeof (TResult) == VoidMarker)
 170                                 return new Action<T1, T2, T3, T4> (ActionRunner<T1, T2, T3, T4>);
 171
 172                         return new Func<T1, T2, T3, T4, TResult> (FuncRunner<T1, T2, T3, T4, TResult>);
 173                 }
 174
 175                 TResult FuncRunner<T1, T2, T3, T4, TResult> (T1 arg1, T2 arg2, T3 arg3, T4 arg4)
 176                 {
 177                         return (TResult) Run (new object [] { arg1, arg2, arg3, arg4 });
 178                 }
 179
 180                 void ActionRunner<T1, T2, T3, T4> (T1 arg1, T2 arg2, T3 arg3, T4 arg4)
 181                 {
 182                         Run (new object [] { arg1, arg2, arg3, arg4 });
 183                 }
 184         }
 185 }