internal static Expression[] GenTypedArgs(GenContext context, ParameterInfo[] parms, IPersistentVector args)
{
Expression[] exprs = new Expression[parms.Length];
for (int i = 0; i < parms.Length; i++)
exprs[i] = GenTypedArg(context,parms[i].ParameterType, (Expr)args.nth(i));
return exprs;
}
public InvokeExpr(string source, IPersistentMap spanMap, Symbol tag, Expr fexpr, IPersistentVector args)
{
_source = source;
_spanMap = spanMap;
_fexpr = fexpr;
_args = args;
VarExpr varFexpr = fexpr as VarExpr;
if (varFexpr != null)
{
Var fvar = varFexpr.Var;
Var pvar = (Var)RT.get(fvar.meta(), Compiler.ProtocolKeyword);
if (pvar != null && Compiler.ProtocolCallsitesVar.isBound)
{
_isProtocol = true;
_siteIndex = Compiler.RegisterProtocolCallsite(fvar);
Object pon = RT.get(pvar.get(), _onKey);
_protocolOn = HostExpr.MaybeType(pon, false);
if (_protocolOn != null)
{
IPersistentMap mmap = (IPersistentMap)RT.get(pvar.get(), _methodMapKey);
Keyword mmapVal = (Keyword)mmap.valAt(Keyword.intern(fvar.sym));
if (mmapVal == null)
{
throw new ArgumentException(String.Format("No method of interface: {0} found for function: {1} of protocol: {2} (The protocol method may have been defined before and removed.)",
_protocolOn.FullName, fvar.Symbol, pvar.Symbol));
}
String mname = Compiler.munge(mmapVal.Symbol.ToString());
IList<MethodBase> methods = Reflector.GetMethods(_protocolOn, mname, null, args.count() - 1, false);
if (methods.Count != 1)
throw new ArgumentException(String.Format("No single method: {0} of interface: {1} found for function: {2} of protocol: {3}",
mname, _protocolOn.FullName, fvar.Symbol, pvar.Symbol));
_onMethod = (MethodInfo) methods[0];
}
}
}
if (tag != null)
_tag = tag;
else if (varFexpr != null)
{
object arglists = RT.get(RT.meta(varFexpr.Var), Compiler.ArglistsKeyword);
object sigTag = null;
for (ISeq s = RT.seq(arglists); s != null; s = s.next())
{
APersistentVector sig = (APersistentVector)s.first();
int restOffset = sig.IndexOf(Compiler.AmpersandSym);
if (args.count() == sig.count() || (restOffset > -1 && args.count() >= restOffset))
{
sigTag = Compiler.TagOf(sig);
break;
}
}
_tag = sigTag ?? varFexpr.Tag;
}
else
_tag = null;
}
public static Expr Parse(ParserContext pcon, IPersistentVector form)
{
ParserContext pconToUse = pcon.EvEx();
bool constant = true;
IPersistentVector args = PersistentVector.EMPTY;
for (int i = 0; i < form.count(); i++ )
{
Expr v = Compiler.Analyze(pconToUse, form.nth(i));
args = (IPersistentVector)args.cons(v);
if ( !(v is LiteralExpr) )
constant = false;
}
Expr ret = new VectorExpr(args);
if ( form is IObj && ((IObj)form).meta() != null )
return Compiler.OptionallyGenerateMetaInit(pcon,form, ret);
else if ( constant )
{
IPersistentVector rv = PersistentVector.EMPTY;
for ( int i=0; i<args.count(); i++ )
{
LiteralExpr ve = (LiteralExpr)args.nth(i);
rv = (IPersistentVector)rv.cons(ve.Val);
}
return new ConstantExpr(rv);
}
else
return ret;
}
public RecurExpr(string source, IPersistentMap spanMap, IPersistentVector loopLocals, IPersistentVector args)
{
_loopLocals = loopLocals;
_args = args;
_source = source;
_spanMap = spanMap;
}
public StaticMethodExpr(Type type, string methodName, IPersistentVector args)
{
_type = type;
_methodName = methodName;
_args = args;
_method = GetMatchingMethod(_type, _args, _methodName);
}
private static void DefineMethod(TypeBuilder proxyTB, IPersistentVector sig)
{
string mname = (string)sig.nth(0);
Type[] paramTypes = GenClass.CreateTypeArray((ISeq)sig.nth(1));
Type retType = (Type)sig.nth(2);
MethodBuilder mb = proxyTB.DefineMethod(mname, MethodAttributes.Abstract | MethodAttributes.Public| MethodAttributes.Virtual, retType, paramTypes);
}
//readonly int _retLocal;
//readonly int _finallyLocal;
#endregion
#region Ctors
public TryExpr(Expr tryExpr, IPersistentVector catchExprs, Expr finallyExpr, int retLocal, int finallyLocal)
{
_tryExpr = tryExpr;
_catchExprs = catchExprs;
_finallyExpr = finallyExpr;
//_retLocal = retLocal;
//_finallyLocal = finallyLocal;
}
public void Setup()
{
IPersistentVector v = LazilyPersistentVector.createOwning(1, 2, 3);
_testNoChange = false;
_obj = _objWithNullMeta = (IObj)v;
_expectedType = typeof(PersistentVector);
}
public void PopLosesTheValue()
{
MapEntry me = new MapEntry(1, "abc");
IPersistentVector v = (IPersistentVector)me.pop();
Expect(v.length(), EqualTo(1));
Expect(v.nth(0), EqualTo(1));
}
public StaticMethodExpr(Type type, string methodName, IPersistentVector args)
{
_type = type;
_methodName = methodName;
_args = args;
_method = GetMatchingMethod(_type, _args, _methodName);
}
public InstanceMethodExpr(Expr target, string methodName, IPersistentVector args)
{
_target = target;
_methodName = methodName;
_args = args;
_method = GetMatchingMethod(target, _args, _methodName);
}
public InvokeExpr(string source, int line, Symbol tag, Expr fexpr, IPersistentVector args)
{
_source = source;
_line = line;
_fexpr = fexpr;
_args = args;
_tag = tag ?? (fexpr is VarExpr ? ((VarExpr)fexpr).Tag : null);
}
public TryExpr(Expr tryExpr, IPersistentVector catchExprs, Expr finallyExpr, int retLocal, int finallyLocal)
{
_tryExpr = tryExpr;
_catchExprs = catchExprs;
_finallyExpr = finallyExpr;
_retLocal = retLocal;
_finallyLocal = finallyLocal;
}
public StaticInvokeExpr(Type target, Type retType, Type[] paramTypes, bool variadic, IPersistentVector args, Symbol tag)
{
_target = target;
_retType = retType;
_paramTypes = paramTypes;
_variadic = variadic;
_args = args;
_tag = tag;
}
public StaticInvokeExpr(Type target, MethodInfo method, bool variadic, IPersistentVector args, object tag)
{
//_target = target;
_method = method;
_retType = method.ReturnType;
_variadic = variadic;
_args = args;
_tag = tag;
}
static bool doEquiv(IPersistentVector v, object obj)
{
if (obj is IPersistentVector ipv)
{
if (ipv.count() != v.count())
{
return(false);
}
for (int i = 0; i < v.count(); i++)
{
if (!Util.equiv(v.nth(i), ipv.nth(i)))
{
return(false);
}
}
return(true);
}
if (obj is IList ilist)
{
if (ilist.Count != v.count()) // THis test in the JVM code can't be right: || ma.GetHashCode() != v.GetHashCode())
{
return(false);
}
for (int i = 0; i < v.count(); i++)
{
if (!Util.equiv(v.nth(i), ilist[i]))
{
return(false);
}
}
return(true);
}
if (!(obj is Sequential))
{
return(false);
}
ISeq ms = RT.seq(obj);
for (int i = 0; i < v.count(); i++, ms = ms.next())
{
if (ms == null || !Util.equiv(v.nth(i), ms.first()))
{
return(false);
}
}
if (ms != null)
{
return(false);
}
return(true);
}
public void AssocNAddsAtEndForEmpty()
{
PersistentVector v1 = PersistentVector.create();
IPersistentVector v2 = v1.assocN(0, "abc");
Expect(v1.count(), EqualTo(0));
Expect(v2.count(), EqualTo(1));
Expect(v2.nth(0), EqualTo("abc"));
}
public static Expr Parse(IPersistentVector form)
{
IPersistentVector args = PersistentVector.EMPTY;
for (int i = 0; i < form.count(); i++ )
args = (IPersistentVector)args.cons(Compiler.GenerateAST(form.nth(i),false));
Expr ret = new VectorExpr(args);
return Compiler.OptionallyGenerateMetaInit(form, ret);
}
public void CreatingOwningOnParamsReturnsVector()
{
IPersistentVector v = LazilyPersistentVector.createOwning(1, 2, 3);
Expect(v.count(), EqualTo(3));
Expect(v.nth(0), EqualTo(1));
Expect(v.nth(1), EqualTo(2));
Expect(v.nth(2), EqualTo(3));
}
public void CreateOnNonEmptyCollectionReturnsVector()
{
IPersistentVector v = LazilyPersistentVector.createOwning(new object[] { 1, 2, 3 });
Expect(v.count(), EqualTo(3));
Expect(v.nth(0), EqualTo(1));
Expect(v.nth(1), EqualTo(2));
Expect(v.nth(2), EqualTo(3));
}
public void NthInRangeWorks()
{
IPersistentVector v = LazilyPersistentVector.createOwning(1, 2, 3);
Expect(v.count(), EqualTo(3));
Expect(v.nth(0), EqualTo(1));
Expect(v.nth(1), EqualTo(2));
Expect(v.nth(2), EqualTo(3));
}
public StaticInvokeExpr(Type target, MethodInfo method, bool variadic, IPersistentVector args, object tag)
{
//_target = target;
_method = method;
_retType = method.ReturnType;
_variadic = variadic;
_args = args;
_tag = tag;
}
public void NthInRangeWorks()
{
IPersistentVector v = LazilyPersistentVector.createOwning(1, 2, 3);
Expect(v.count()).To.Equal(3);
Expect(v.nth(0)).To.Equal(1);
Expect(v.nth(1)).To.Equal(2);
Expect(v.nth(2)).To.Equal(3);
}
private static object[] GetCtorArgs(IPersistentVector v)
{
object[] args = new object[v.length()];
for (int i = 0; i < v.length(); i++)
{
args[i] = v.nth(i);
}
return(args);
}
/// <summary>
/// Create a <see cref="PersistentVector">PersistentVector</see> from an <see cref="ISeq">ISeq</see>.
/// </summary>
/// <param name="items">A sequence of items.</param>
/// <returns>An initialized vector.</returns>
static public PersistentVector create(ISeq items)
{
IPersistentVector ret = EMPTY;
for (; items != null; items = items.next())
{
ret = ret.cons(items.first());
}
return((PersistentVector)ret);
}
/// <summary>
/// Create a <see cref="PersistentVector">PersistentVector</see> from an array of items.
/// </summary>
/// <param name="items"></param>
/// <returns></returns>
static public PersistentVector create(params object[] items)
{
IPersistentVector ret = EMPTY;
foreach (object item in items)
{
ret = ret.cons(item);
}
return((PersistentVector)ret);
}
private static Type[] SeqToTypeArray(IPersistentVector interfaces)
{
Type[] types = new Type[interfaces.count()];
for (int i = 0; i < interfaces.count(); i++)
{
types[i] = (Type)interfaces.nth(i);
}
return(types);
}
public object Eval()
{
IPersistentVector ret = PersistentVector.EMPTY;
for (int i = 0; i < _args.count(); i++)
{
ret = (IPersistentVector)ret.cons(((Expr)_args.nth(i)).Eval());
}
return(ret);
}
public StaticMethodExpr(string source, int line, Type type, string methodName, IPersistentVector args)
{
_source = source;
_line = line;
_type = type;
_methodName = methodName;
_args = args;
_method = GetMatchingMethod(line, _type, _args, _methodName);
}
public static Expr Parse(Var v, ISeq args, object tag)
{
if (!v.isBound || v.get() == null)
{
//Console.WriteLine("Not bound: {0}", v);
return(null);
}
Type target = v.get().GetType();
MethodInfo[] allMethods = target.GetMethods();
bool variadic = false;
int argcount = RT.count(args);
MethodInfo method = null;
ParameterInfo[] pInfos = null;
foreach (MethodInfo m in allMethods)
{
//Console.WriteLine("Method {0}", m.Name);
if (m.IsStatic && m.Name.Equals("invokeStatic"))
{
pInfos = m.GetParameters();
if (argcount == pInfos.Length)
{
method = m;
variadic = argcount > 0 && pInfos[pInfos.Length - 1].ParameterType == typeof(ISeq);
break;
}
else if (argcount > pInfos.Length &&
pInfos.Length > 0 &&
pInfos[pInfos.Length - 1].ParameterType == typeof(ISeq))
{
method = m;
variadic = true;
break;
}
}
}
if (method == null)
{
return(null);
}
IPersistentVector argv = PersistentVector.EMPTY;
for (ISeq s = RT.seq(args); s != null; s = s.next())
{
argv = argv.cons(Compiler.Analyze(new ParserContext(RHC.Expression), s.first()));
}
return(new StaticInvokeExpr(target, method, variadic, argv, tag));
}
public static Expr Parse(ISeq form)
{
Expr fexpr = Compiler.GenerateAST(form.first());
IPersistentVector args = PersistentVector.EMPTY;
for (ISeq s = RT.seq(form.next()); s != null; s = s.next())
{
args = args.cons(Compiler.GenerateAST(s.first()));
}
return(new InvokeExpr(Compiler.TagOf(form), fexpr, args));
}
internal static int GetMatchingParams(string methodName, List<ParameterInfo[]> parmlists, IPersistentVector argexprs, List<Type> rets)
{
// Assume matching lengths
int matchIndex = -1;
bool tied = false;
bool foundExact = false;
for (int i = 0; i < parmlists.Count; i++)
{
bool match = true;
ISeq aseq = argexprs.seq();
int exact = 0;
for (int p = 0; match && p < argexprs.count() && aseq != null; ++p, aseq = aseq.next())
{
Expr arg = (Expr)aseq.first();
Type atype = arg.HasClrType ? arg.ClrType : typeof(object);
Type ptype = parmlists[i][p].ParameterType;
if (arg.HasClrType && atype == ptype)
exact++;
else
match = Reflector.ParamArgTypeMatch(ptype, atype);
}
if (exact == argexprs.count())
{
if ( !foundExact || matchIndex == -1 || rets[matchIndex].IsAssignableFrom(rets[i]))
matchIndex = i;
foundExact = true;
}
else if (match && !foundExact)
{
if (matchIndex == -1)
matchIndex = i;
else
{
if (Reflector.Subsumes(parmlists[i], parmlists[matchIndex]))
{
matchIndex = i;
tied = false;
}
else if (Array.Equals(parmlists[i], parmlists[matchIndex]))
if (rets[matchIndex].IsAssignableFrom(rets[i]))
matchIndex = i;
else if (!Reflector.Subsumes(parmlists[matchIndex], parmlists[i]))
tied = true;
}
}
}
if (tied)
throw new ArgumentException("More than one matching method found: " + methodName);
return matchIndex;
}
static void AddMethod(Dictionary <IPersistentVector, List <MethodInfo> > mm, IPersistentVector sig, MethodInfo m)
{
List <MethodInfo> value;
if (!mm.TryGetValue(sig, out value))
{
value = new List <MethodInfo>();
mm[sig] = value;
}
value.Add(m);
}
static string[] InterfaceNames(IPersistentVector interfaces)
{
int icnt = interfaces.count();
string[] inames = icnt > 0 ? new string[icnt] : null;
for (int i = 0; i < icnt; i++)
{
inames[i] = SlashName((Type)interfaces.nth(i));
}
return(inames);
}
public Delegate GenerateTypedDelegate(Type delegateType, Symbol optName, IPersistentVector argList, ISeq body)
{
ScriptSource scriptSource = Engine.CreateScriptSourceFromString("<internal>");
LambdaExpression ast = Generator.GenerateTypedDelegateExpression(GetLanguageContext(), delegateType, optName, argList, body);
return ast.Compile();
//ast = new GlobalLookupRewriter().RewriteLambda(ast); -- doesn't work unless no args
//ScriptCode code = new ScriptCode(ast, GetSourceUnit(scriptSource));
//return code;
}
public void ConsOnNon2IPVFails()
{
Dictionary <int, string> d = new Dictionary <int, string>();
d[1] = "a";
d[2] = "b";
IPersistentMap m = PersistentArrayMap.create(d);
IPersistentVector v = PersistentVector.create(2, "c", 3, "d");
IPersistentMap c = m.cons(v);
}
private static IPersistentVector flattenMap(object form)
{
IPersistentVector keyvals = PersistentVector.EMPTY;
for (ISeq s = RT.seq(form); s != null; s = s.next())
{
IMapEntry e = (IMapEntry)s.first();
keyvals = (IPersistentVector)keyvals.cons(e.key());
keyvals = (IPersistentVector)keyvals.cons(e.val());
}
return(keyvals);
}
static void ConsiderMethod(MethodInfo m, Dictionary <IPersistentVector, List <MethodInfo> > mm)
{
IPersistentVector mk = MSig(m);
if (!(mm.ContainsKey(mk) ||
!(m.IsPublic || m.IsFamily) ||
m.IsStatic ||
m.IsFinal))
{
AddMethod(mm, mk, m);
}
}
public InstanceMethodExpr(string source, int line, Expr target, string methodName, IPersistentVector args)
{
_source = source;
_line = line;
_target = target;
_methodName = methodName;
_args = args;
if (target.HasClrType && target.ClrType == null)
throw new ArgumentException(String.Format("Attempt to call instance method {0} on nil", methodName));
_method = GetMatchingMethod(line, target, _args, _methodName);
}
internal static void EmitArgsAsArray(IPersistentVector args, ObjExpr objx, CljILGen ilg)
{
ilg.EmitInt(args.count());
ilg.Emit(OpCodes.Newarr, typeof(Object));
for (int i = 0; i < args.count(); i++)
{
ilg.Emit(OpCodes.Dup);
ilg.EmitInt(i);
((Expr)args.nth(i)).Emit(RHC.Expression, objx, ilg);
ilg.Emit(OpCodes.Stelem_Ref);
}
}
public static Expr Parse(IPersistentVector form)
{
IPersistentVector args = PersistentVector.EMPTY;
for (int i = 0; i < form.count(); i++)
{
args = (IPersistentVector)args.cons(Compiler.GenerateAST(form.nth(i)));
}
Expr ret = new VectorExpr(args);
return(Compiler.OptionallyGenerateMetaInit(form, ret));
}
public static Expr Parse(IPersistentSet form)
{
IPersistentVector keys = PersistentVector.EMPTY;
for (ISeq s = RT.seq(form); s != null; s = s.next())
{
object e = s.first();
keys = (IPersistentVector)keys.cons(Compiler.GenerateAST(e));
}
Expr ret = new SetExpr(keys);
return(Compiler.OptionallyGenerateMetaInit(form, ret));
}
/// <summary>
/// Initialize a subvector, with the given metadata and start/end indices.
/// </summary>
/// <param name="meta">The metatdata to attach.</param>
/// <param name="v">The vector to subvector.</param>
/// <param name="start">The start index of the subvector.</param>
/// <param name="end">The end index of the subvector.</param>
public SubVector(IPersistentMap meta, IPersistentVector v, int start, int end)
: base(meta)
{
if (v is SubVector)
{
SubVector sv = (SubVector)v;
start += sv._start;
end += sv._start;
v = sv._v;
}
_v = v;
_start = start;
_end = end;
}
/// <summary>
/// Initialize a subvector, with the given metadata and start/end indices.
/// </summary>
/// <param name="meta">The metatdata to attach.</param>
/// <param name="v">The vector to subvector.</param>
/// <param name="start">The start index of the subvector.</param>
/// <param name="end">The end index of the subvector.</param>
public SubVector(IPersistentMap meta, IPersistentVector v, int start, int end)
{
_meta = meta;
if (v is SubVector sv)
{
start += sv._start;
end += sv._start;
v = sv._v;
}
_v = v;
_start = start;
_end = end;
}
public static Expr Parse(IPersistentMap form)
{
IPersistentVector keyvals = PersistentVector.EMPTY;
for (ISeq s = RT.seq(form); s != null; s = s.next())
{
IMapEntry e = (IMapEntry)s.first();
keyvals = (IPersistentVector)keyvals.cons(Compiler.GenerateAST(e.key()));
keyvals = (IPersistentVector)keyvals.cons(Compiler.GenerateAST(e.val()));
}
Expr ret = new MapExpr(keyvals);
return(Compiler.OptionallyGenerateMetaInit(form, ret));
}
public void PopOnNonEmptyWorks()
{
IPersistentVector v = LazilyPersistentVector.createOwning(1, 2, 3);
IPersistentVector v2 = (IPersistentVector)((IPersistentStack)v).pop();
Expect(v.count(), EqualTo(3));
Expect(v.nth(0), EqualTo(1));
Expect(v.nth(1), EqualTo(2));
Expect(v.nth(2), EqualTo(3));
Expect(v2.count(), EqualTo(2));
Expect(v2.nth(0), EqualTo(1));
Expect(v2.nth(1), EqualTo(2));
}
public InvokeExpr(string source, IPersistentMap spanMap, Symbol tag, Expr fexpr, IPersistentVector args)
{
_source = source;
_spanMap = spanMap;
_fexpr = fexpr;
_args = args;
if (fexpr is VarExpr)
{
Var fvar = ((VarExpr)fexpr).Var;
Var pvar = (Var)RT.get(fvar.meta(), Compiler.PROTOCOL_KEY);
if (pvar != null && Compiler.PROTOCOL_CALLSITES.isBound)
{
_isProtocol = true;
_siteIndex = Compiler.RegisterProtocolCallsite(fvar);
Object pon = RT.get(pvar.get(), _onKey);
_protocolOn = HostExpr.MaybeType(pon, false);
if (_protocolOn != null)
{
IPersistentMap mmap = (IPersistentMap)RT.get(pvar.get(), _methodMapKey);
Keyword mmapVal = (Keyword)mmap.valAt(Keyword.intern(fvar.sym));
if (mmapVal == null)
{
throw new ArgumentException(String.Format("No method of interface: {0} found for function: {1} of protocol: {2} (The protocol method may have been defined before and removed.)",
_protocolOn.FullName, fvar.Symbol, pvar.Symbol));
}
String mname = Compiler.munge(mmapVal.Symbol.ToString());
List<MethodInfo> methods = Reflector.GetMethods(_protocolOn, mname, args.count() - 1, false);
if (methods.Count != 1)
throw new ArgumentException(String.Format("No single method: {0} of interface: {1} found for function: {2} of protocol: {3}",
mname, _protocolOn.FullName, fvar.Symbol, pvar.Symbol));
_onMethod = methods[0];
}
}
//else if (pvar == null && Compiler.VAR_CALLSITES.isBound
// && fvar.Namespace.Name.Name.StartsWith("clojure")
// && !RT.booleanCast(RT.get(RT.meta(fvar), _dynamicKey)))
//{
// // Java TODO: more specific criteria for binding these
// _isDirect = true;
// _siteIndex = Compiler.RegisterVarCallsite(fvar);
//}
}
_tag = tag ?? (fexpr is VarExpr ? ((VarExpr)fexpr).Tag : null);
}
public InvokeExpr(string source, IPersistentMap spanMap, Symbol tag, Expr fexpr, IPersistentVector args)
{
_source = source;
_spanMap = spanMap;
_fexpr = fexpr;
_args = args;
if (fexpr is VarExpr)
{
Var fvar = ((VarExpr)fexpr).Var;
Var pvar = (Var)RT.get(fvar.meta(), Compiler.PROTOCOL_KEY);
if (pvar != null && Compiler.PROTOCOL_CALLSITES.isBound)
{
_isProtocol = true;
_siteIndex = Compiler.RegisterProtocolCallsite(fvar);
Object pon = RT.get(pvar.get(), _onKey);
_protocolOn = HostExpr.MaybeType(pon, false);
if (_protocolOn != null)
{
IPersistentMap mmap = (IPersistentMap)RT.get(pvar.get(), _methodMapKey);
Keyword mmapVal = (Keyword)mmap.valAt(Keyword.intern(fvar.sym));
if (mmapVal == null)
{
throw new ArgumentException(String.Format("No method of interface: {0} found for function: {1} of protocol: {2} (The protocol method may have been defined before and removed.)",
_protocolOn.FullName, fvar.Symbol, pvar.Symbol));
}
String mname = Compiler.munge(mmapVal.Symbol.ToString());
List<MethodBase> methods = Reflector.GetMethods(_protocolOn, mname, null, args.count() - 1, false);
if (methods.Count != 1)
throw new ArgumentException(String.Format("No single method: {0} of interface: {1} found for function: {2} of protocol: {3}",
mname, _protocolOn.FullName, fvar.Symbol, pvar.Symbol));
_onMethod = (MethodInfo) methods[0];
}
}
}
_tag = tag ?? (fexpr is VarExpr ? ((VarExpr)fexpr).Tag : null);
}
private static void DefineMethod(TypeBuilder proxyTB, IPersistentVector sig)
{
Symbol mname = (Symbol)sig.nth(0);
Type[] paramTypes = GenClass.CreateTypeArray((ISeq)sig.nth(1));
Type retType = (Type)sig.nth(2);
ISeq pmetas = (ISeq)(sig.count() >= 4 ? sig.nth(3) : null);
MethodBuilder mb = proxyTB.DefineMethod(mname.Name, MethodAttributes.Abstract | MethodAttributes.Public| MethodAttributes.Virtual, retType, paramTypes);
SetCustomAttributes(mb, GenInterface.ExtractAttributes(RT.meta(mname)));
int i=1;
for (ISeq s = pmetas; s != null; s = s.next(), i++)
{
IPersistentMap meta = GenInterface.ExtractAttributes((IPersistentMap)s.first());
if (meta != null && meta.count() > 0)
{
ParameterBuilder pb = mb.DefineParameter(i, ParameterAttributes.None, String.Format("p_{0}",i));
GenInterface.SetCustomAttributes(pb, meta);
}
}
}
public SetExpr(IPersistentVector keys)
{
_keys = keys;
}
internal static ObjExpr Build(
IPersistentVector interfaceSyms,
IPersistentVector fieldSyms,
Symbol thisSym,
string tagName,
Symbol className,
Symbol typeTag,
ISeq methodForms,
Object frm)
{
NewInstanceExpr ret = new NewInstanceExpr(null);
ret._src = frm;
ret._name = className.ToString();
ret._classMeta = GenInterface.ExtractAttributes(RT.meta(className));
ret.InternalName = ret.Name; // ret.Name.Replace('.', '/');
// Java: ret.objtype = Type.getObjectType(ret.internalName);
if (thisSym != null)
ret._thisName = thisSym.Name;
if (fieldSyms != null)
{
IPersistentMap fmap = PersistentHashMap.EMPTY;
object[] closesvec = new object[2 * fieldSyms.count()];
for (int i = 0; i < fieldSyms.count(); i++)
{
Symbol sym = (Symbol)fieldSyms.nth(i);
LocalBinding lb = new LocalBinding(-1, sym, null, new MethodParamExpr(Compiler.TagType(Compiler.TagOf(sym))), false, false);
fmap = fmap.assoc(sym, lb);
closesvec[i * 2] = lb;
closesvec[i * 2 + 1] = lb;
}
// Java TODO: inject __meta et al into closes - when?
// use array map to preserve ctor order
ret._closes = new PersistentArrayMap(closesvec);
ret._fields = fmap;
for (int i = fieldSyms.count() - 1; i >= 0 && ((Symbol)fieldSyms.nth(i)).Name.StartsWith("__"); --i)
ret._altCtorDrops++;
}
// Java TODO: set up volatiles
//ret._volatiles = PersistentHashSet.create(RT.seq(RT.get(ret._optionsMap, volatileKey)));
IPersistentVector interfaces = PersistentVector.EMPTY;
for (ISeq s = RT.seq(interfaceSyms); s != null; s = s.next())
{
Type t = (Type)Compiler.Resolve((Symbol)s.first());
if (!t.IsInterface)
throw new ArgumentException("only interfaces are supported, had: " + t.Name);
interfaces = interfaces.cons(t);
}
Type superClass = typeof(Object);
Dictionary<IPersistentVector, List<MethodInfo>> overrideables;
GatherMethods(superClass, RT.seq(interfaces), out overrideables);
ret._methodMap = overrideables;
//string[] inames = InterfaceNames(interfaces);
Type stub = CompileStub(superClass, ret, SeqToTypeArray(interfaces),frm);
Symbol thisTag = Symbol.intern(null, stub.FullName);
//Symbol stubTag = Symbol.intern(null,stub.FullName);
//Symbol thisTag = Symbol.intern(null, tagName);
// Needs its own GenContext so it has its own DynInitHelper
// Can't reuse Compiler.EvalContext if it is a DefType because we have to use the given name and will get a conflict on redefinition
GenContext context = Compiler.COMPILER_CONTEXT.get() as GenContext ?? (ret.IsDefType ? new GenContext("deftype" + RT.nextID().ToString(),".dll",".",true) : Compiler.EvalContext);
GenContext genC = context.WithNewDynInitHelper(ret.InternalName + "__dynInitHelper_" + RT.nextID().ToString());
//genC.FnCompileMode = FnMode.Full;
try
{
Var.pushThreadBindings(
RT.map(
Compiler.CONSTANTS, PersistentVector.EMPTY,
Compiler.CONSTANT_IDS, new IdentityHashMap(),
Compiler.KEYWORDS, PersistentHashMap.EMPTY,
Compiler.VARS, PersistentHashMap.EMPTY,
Compiler.KEYWORD_CALLSITES, PersistentVector.EMPTY,
Compiler.PROTOCOL_CALLSITES, PersistentVector.EMPTY,
Compiler.VAR_CALLSITES, PersistentVector.EMPTY,
Compiler.COMPILER_CONTEXT, genC
));
if (ret.IsDefType)
{
Var.pushThreadBindings(
RT.map(
Compiler.METHOD, null,
Compiler.LOCAL_ENV, ret._fields,
Compiler.COMPILE_STUB_SYM, Symbol.intern(null, tagName),
Compiler.COMPILE_STUB_CLASS, stub
));
}
// now (methodname [args] body)*
// TODO: SourceLocation?
//ret.line = (Integer)LINE.deref();
IPersistentCollection methods = null;
for (ISeq s = methodForms; s != null; s = RT.next(s))
{
NewInstanceMethod m = NewInstanceMethod.Parse(ret, (ISeq)RT.first(s), thisTag, overrideables);
methods = RT.conj(methods, m);
}
ret._methods = methods;
ret.Keywords = (IPersistentMap)Compiler.KEYWORDS.deref();
ret.Vars = (IPersistentMap)Compiler.VARS.deref();
ret.Constants = (PersistentVector)Compiler.CONSTANTS.deref();
ret._constantsID = RT.nextID();
ret.KeywordCallsites = (IPersistentVector)Compiler.KEYWORD_CALLSITES.deref();
ret.ProtocolCallsites = (IPersistentVector)Compiler.PROTOCOL_CALLSITES.deref();
ret.VarCallsites = (IPersistentVector)Compiler.VAR_CALLSITES.deref();
}
finally
{
if (ret.IsDefType)
Var.popThreadBindings();
Var.popThreadBindings();
}
ret.Compile(stub, interfaces, false, genC);
Compiler.RegisterDuplicateType(ret.CompiledType);
return ret;
}
internal static Expression[] GenTypedArgArray(GenContext context, ParameterInfo[] infos, IPersistentVector args)
{
Expression[] exprs = new Expression[args.count()];
for (int i = 0; i < infos.Length; i++)
{
Expr e = (Expr)args.nth(i);
// Java: this is in a try/catch, where the catch prints a stack trace
if (MaybePrimitiveType(e) == infos[i].ParameterType)
exprs[i] = ((MaybePrimitiveExpr)e).GenDlrUnboxed(context);
else
// Java follows this with: HostExpr.emitUnboxArg(fn, gen, parameterTypes[i]);
//exprs[i] = e.GenDlr(context);
exprs[i] = Expression.Convert(e.GenDlr(context), infos[i].ParameterType); ;
}
return exprs;
}
private static Type[] SeqToTypeArray(IPersistentVector interfaces)
{
Type[] types = new Type[interfaces.count()];
for (int i = 0; i < interfaces.count(); i++)
types[i] = (Type)interfaces.nth(i);
return types;
}
public Type Compile(Type superType, Type stubType, IPersistentVector interfaces, bool onetimeUse, GenContext context)
{
if (_compiledType != null)
return _compiledType;
string publicTypeName = IsDefType || (_isStatic && Compiler.IsCompiling) ? InternalName : InternalName + "__" + RT.nextID();
//Console.WriteLine("DefFn {0}, {1}", publicTypeName, context.AssemblyBuilder.GetName().Name);
_typeBuilder = context.AssemblyGen.DefinePublicType(publicTypeName, superType, true);
context = context.WithNewDynInitHelper().WithTypeBuilder(_typeBuilder);
Var.pushThreadBindings(RT.map(Compiler.CompilerContextVar, context));
try
{
if (interfaces != null)
{
for (int i = 0; i < interfaces.count(); i++)
_typeBuilder.AddInterfaceImplementation((Type)interfaces.nth(i));
}
ObjExpr.MarkAsSerializable(_typeBuilder);
GenInterface.SetCustomAttributes(_typeBuilder, _classMeta);
try
{
if (IsDefType)
{
Compiler.RegisterDuplicateType(_typeBuilder);
Var.pushThreadBindings(RT.map(
Compiler.CompileStubOrigClassVar, stubType
));
//,
//Compiler.COMPILE_STUB_CLASS, _baseType));
}
EmitConstantFieldDefs(_typeBuilder);
EmitKeywordCallsiteDefs(_typeBuilder);
DefineStaticConstructor(_typeBuilder);
if (SupportsMeta)
_metaField = _typeBuilder.DefineField("__meta", typeof(IPersistentMap), FieldAttributes.Public | FieldAttributes.InitOnly);
EmitClosedOverFields(_typeBuilder);
EmitProtocolCallsites(_typeBuilder);
_ctorInfo = EmitConstructor(_typeBuilder, superType);
if (_altCtorDrops > 0)
EmitFieldOnlyConstructor(_typeBuilder, superType);
if (SupportsMeta)
{
EmitNonMetaConstructor(_typeBuilder, superType);
EmitMetaFunctions(_typeBuilder);
}
EmitStatics(_typeBuilder);
EmitMethods(_typeBuilder);
//if (KeywordCallsites.count() > 0)
// EmitSwapThunk(_typeBuilder);
_compiledType = _typeBuilder.CreateType();
if (context.DynInitHelper != null)
context.DynInitHelper.FinalizeType();
// If we don't pick up the ctor after we finalize the type,
// we sometimes get a ctor which is not a RuntimeConstructorInfo
// This causes System.DynamicILGenerator.Emit(opcode,ContructorInfo) to blow up.
// The error says the ConstructorInfo is null, but there is a second case in the code.
// Thank heavens one can run Reflector on mscorlib.
ConstructorInfo[] cis = _compiledType.GetConstructors();
foreach (ConstructorInfo ci in cis)
{
if (ci.GetParameters().Length == CtorTypes().Length)
{
_ctorInfo = ci;
break;
}
}
return _compiledType;
}
finally
{
if (IsDefType)
Var.popThreadBindings();
}
}
finally
{
Var.popThreadBindings();
}
}
internal static Expression GenArgArray(GenContext context, IPersistentVector args)
{
Expression[] exprs = new Expression[args.count()];
for (int i = 0; i < args.count(); i++)
{
Expr arg = (Expr)args.nth(i);
exprs[i] = Compiler.MaybeBox(arg.GenDlr(context));
}
Expression argArray = Expression.NewArrayInit(typeof(object), exprs);
return argArray;
}
/// <summary>
/// Send an action (encapsulated message).
/// </summary>
/// <param name="action">The action to execute.</param>
/// <remarks>
/// <para>If there is a transaction running on this thread,
/// defer execution until the transaction ends
/// (enqueue the action on the transaction).</para>
/// <para>If there is already an action running, enqueue it (nested).</para>
/// <para>Otherwise, queue it for execution.</para>
/// </remarks>
internal static void DispatchAction(Action action)
{
LockingTransaction trans = LockingTransaction.GetRunning();
if (trans != null)
trans.Enqueue(action);
else if (_nested != null)
_nested = _nested.cons(action);
else
action.Agent.Enqueue(action);
}
private static object[] GetCtorArgs(IPersistentVector v)
{
object[] args = new object[v.length()];
for (int i = 0; i < v.length(); i++)
args[i] = v.nth(i);
return args;
}
static string[] InterfaceNames(IPersistentVector interfaces)
{
int icnt = interfaces.count();
string[] inames = icnt > 0 ? new string[icnt] : null;
for (int i = 0; i < icnt; i++)
inames[i] = SlashName((Type)interfaces.nth(i));
return inames;
}
public LetFnExpr(IPersistentVector bindingInits, Expr body)
{
_bindingInits = bindingInits;
_body = body;
}
internal static Expression[] GenTypedArgs(ObjExpr objx, GenContext context, Type[] paramTypes, IPersistentVector args)
{
Expression[] exprs = new Expression[paramTypes.Length];
for (int i = 0; i < paramTypes.Length; i++)
exprs[i] = GenTypedArg(objx, context, paramTypes[i], (Expr)args.nth(i));
return exprs;
}