public static Expression CompileMac(object stuff, Environment environment) { object args = ((Pair)stuff).First(); Pair body = (Pair)((Pair)stuff).Rest(); string doc = ""; if ((body.Length() > 1) && (body.First() is string)) { doc = (string)body.First(); body = (Pair)body.Rest(); } Pair implicitProgn = new Pair(PROGN, body); // Dangerous if it gets redefined object v = Compile(implicitProgn, environment); return(Expression.Call(null, makeMacroMethodInfo, Expression.Constant(args), Expression.Constant(v), Expression.Constant(doc), environmentParameter)); }
public static Expression CompileCall(Pair c, Environment environment) { string dotNetExpression = ((Symbol)c.First()).Name; int n = dotNetExpression.LastIndexOf('.'); string typeName = dotNetExpression.Substring(0, n); string methodName = dotNetExpression.Substring(n + 1); Type t = ClrGlue.FindType(typeName, Runtime.Namespaces); MemberInfo m = ClrGlue.FindUnambiguousMember(methodName, t, c.Length() - 1); if (m == null) { // If we cant find an unambiguos MemberInfo then we'll // have to compile a call to CallStaticMethod instead. // This will look for a method again reflectively at // runtime, so this will be a performance hit Expression[] es = CompileArgs1(c.Rest(), environment); Expression[] ees = new Expression[3]; ees[0] = Expression.Constant(methodName); ees[1] = Expression.Constant(t, typeof(Type)); ees[2] = Expression.NewArrayInit(typeof(object), es); return Expression.Call(null, callStaticMethodMethodInfo, ees); } else { // We know what we're doing at compile time, so lets compile // up the call now. // No need for runtime reflection = better performance !! if (m is MethodInfo) { if (((MethodInfo)m).IsStatic) { Expression[] es = CompileArgsX(c.Rest(), ((MethodInfo)m).GetParameters(), environment); return Expression.Call(null, (MethodInfo)m, es); } else { // Its a virtual call Expression[] es = CompileArgsX(c.Rest().Rest(), ((MethodInfo)m).GetParameters(), environment); Expression o = Compile1(c.Rest().First(),environment); return Expression.Call(o, (MethodInfo)m, es); } } if (m is PropertyInfo) return Expression.Property(null, (PropertyInfo)m); if (m is FieldInfo) return Expression.Field(null, (FieldInfo)m); return null; } }
public static Expression CompileCall(Pair c, Environment environment) { string dotNetExpression = ((Symbol)c.First()).Name; int n = dotNetExpression.LastIndexOf('.'); string typeName = dotNetExpression.Substring(0, n); string methodName = dotNetExpression.Substring(n + 1); Type t = ClrGlue.FindType(typeName, Runtime.Namespaces); MemberInfo m = ClrGlue.FindUnambiguousMember(methodName, t, c.Length() - 1); if (m == null) { // If we cant find an unambiguos MemberInfo then we'll // have to compile a call to CallStaticMethod instead. // This will look for a method again reflectively at // runtime, so this will be a performance hit Expression[] es = CompileArgs1(c.Rest(), environment); Expression[] ees = new Expression[3]; ees[0] = Expression.Constant(methodName); ees[1] = Expression.Constant(t, typeof(Type)); ees[2] = Expression.NewArrayInit(typeof(object), es); return(Expression.Call(null, callStaticMethodMethodInfo, ees)); } else { // We know what we're doing at compile time, so lets compile // up the call now. // No need for runtime reflection = better performance !! if (m is MethodInfo) { if (((MethodInfo)m).IsStatic) { Expression[] es = CompileArgsX(c.Rest(), ((MethodInfo)m).GetParameters(), environment); return(Expression.Call(null, (MethodInfo)m, es)); } else { // Its a virtual call Expression[] es = CompileArgsX(c.Rest().Rest(), ((MethodInfo)m).GetParameters(), environment); Expression o = Compile1(c.Rest().First(), environment); return(Expression.Call(o, (MethodInfo)m, es)); } } if (m is PropertyInfo) { return(Expression.Property(null, (PropertyInfo)m)); } if (m is FieldInfo) { return(Expression.Field(null, (FieldInfo)m)); } return(null); } }