public Expr Parse(ParserContext pcon, object frm)
{
// frm is: (reify this-name? [interfaces] (method-name [args] body)* )
ISeq form = (ISeq)frm;
ObjMethod enclosingMethod = (ObjMethod)Compiler.MethodVar.deref();
string baseName = enclosingMethod != null
? (ObjExpr.TrimGenId(enclosingMethod.Objx.Name) + "$")
: (Compiler.munge(Compiler.CurrentNamespace.Name.Name) + "$");
string simpleName = "reify__" + RT.nextID();
string className = baseName + simpleName;
ISeq rform = RT.next(form);
IPersistentVector interfaces = ((IPersistentVector)RT.first(rform)).cons(Symbol.intern("clojure.lang.IObj"));
rform = RT.next(rform);
ObjExpr ret = Build(interfaces, null, null, className, Symbol.intern(className), null, rform, frm);
IObj iobj = frm as IObj;
if (iobj != null && iobj.meta() != null)
{
return(new MetaExpr(ret, MapExpr.Parse(pcon.EvalOrExpr(), iobj.meta())));
}
else
{
return(ret);
}
}
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(),false));
keyvals = (IPersistentVector)keyvals.cons(Compiler.GenerateAST(e.val(),false));
}
Expr ret = new MapExpr(keyvals);
return Compiler.OptionallyGenerateMetaInit(form, ret);
}
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));
}
private static bool IncludesExplicitMetadata(MapExpr expr)
{
for (int i = 0; i < expr.KeyVals.count(); i += 2)
{
Keyword k = ((KeywordExpr)expr.KeyVals.nth(i)).Kw;
if ((k != RT.FileKey) &&
(k != RT.DeclaredKey) &&
(k != RT.SourceSpanKey) &&
(k != RT.LineKey))
{
return(true);
}
}
return(false);
}
public static Expr Parse(ParserContext pcon, IPersistentMap form)
{
ParserContext pconToUse = pcon.EvalOrExpr();
bool keysConstant = true;
bool valsConstant = true;
bool allConstantKeysUnique = true;
IPersistentSet constantKeys = PersistentHashSet.EMPTY;
IPersistentVector keyvals = PersistentVector.EMPTY;
for (ISeq s = RT.seq(form); s != null; s = s.next())
{
IMapEntry e = (IMapEntry)s.first();
Expr k = Compiler.Analyze(pconToUse, e.key());
Expr v = Compiler.Analyze(pconToUse, e.val());
keyvals = (IPersistentVector)keyvals.cons(k);
keyvals = (IPersistentVector)keyvals.cons(v);
if (k is LiteralExpr)
{
object kval = k.Eval();
if (constantKeys.contains(kval))
{
allConstantKeysUnique = false;
}
else
{
constantKeys = (IPersistentSet)constantKeys.cons(kval);
}
}
else
{
keysConstant = false;
}
if (!(v is LiteralExpr))
{
valsConstant = false;
}
}
Expr ret = new MapExpr(keyvals);
if (form is IObj iobjForm && iobjForm.meta() != null)
{
return(Compiler.OptionallyGenerateMetaInit(pcon, form, ret));
}
public static Expr Parse(ParserContext pcon, IPersistentMap form)
{
ParserContext pconToUse = pcon.EvalOrExpr();
bool constant = true;
IPersistentVector keyvals = PersistentVector.EMPTY;
for (ISeq s = RT.seq(form); s != null; s = s.next())
{
IMapEntry e = (IMapEntry)s.first();
Expr k = Compiler.Analyze(pconToUse, e.key());
Expr v = Compiler.Analyze(pconToUse, e.val());
keyvals = (IPersistentVector)keyvals.cons(k);
keyvals = (IPersistentVector)keyvals.cons(v);
if (!(k is LiteralExpr && v is LiteralExpr))
{
constant = false;
}
}
Expr ret = new MapExpr(keyvals);
IObj iobjForm = form as IObj;
if (iobjForm != null && iobjForm.meta() != null)
{
return(Compiler.OptionallyGenerateMetaInit(pcon, form, ret));
}
else if (constant)
{
// This 'optimzation' works, mostly, unless you have nested map values.
// The nested map values do not participate in the constants map, so you end up with the code to create the keys.
// Result: huge duplication of keyword creation. 3X increase in init time to the REPL.
//IPersistentMap m = PersistentHashMap.EMPTY;
//for (int i = 0; i < keyvals.length(); i += 2)
// m = m.assoc(((LiteralExpr)keyvals.nth(i)).Val, ((LiteralExpr)keyvals.nth(i + 1)).Val);
//return new ConstantExpr(m);
return(ret);
}
else
{
return(ret);
}
}
public static Expr Parse(ParserContext pcon, IPersistentMap form)
{
ParserContext pconToUse = pcon.EvalOrExpr();
bool constant = true;
IPersistentVector keyvals = PersistentVector.EMPTY;
for (ISeq s = RT.seq(form); s != null; s = s.next())
{
IMapEntry e = (IMapEntry)s.first();
Expr k = Compiler.Analyze(pconToUse, e.key());
Expr v = Compiler.Analyze(pconToUse, e.val());
keyvals = (IPersistentVector)keyvals.cons(k);
keyvals = (IPersistentVector)keyvals.cons(v);
if (!(k is LiteralExpr && v is LiteralExpr))
constant = false;
}
Expr ret = new MapExpr(keyvals);
IObj iobjForm = form as IObj;
if (iobjForm != null && iobjForm.meta() != null)
return Compiler.OptionallyGenerateMetaInit(pcon, form, ret);
else if (constant)
{
// This 'optimzation' works, mostly, unless you have nested map values.
// The nested map values do not participate in the constants map, so you end up with the code to create the keys.
// Result: huge duplication of keyword creation. 3X increase in init time to the REPL.
//IPersistentMap m = PersistentHashMap.EMPTY;
//for (int i = 0; i < keyvals.length(); i += 2)
// m = m.assoc(((LiteralExpr)keyvals.nth(i)).Val, ((LiteralExpr)keyvals.nth(i + 1)).Val);
//return new ConstantExpr(m);
return ret;
}
else
return ret;
}
private static bool IncludesExplicitMetadata(MapExpr expr)
{
for (int i = 0; i < expr.KeyVals.count(); i += 2)
{
Keyword k = ((KeywordExpr)expr.KeyVals.nth(i)).Kw;
if ((k != RT.FileKey) &&
(k != RT.DeclaredKey) &&
(k != RT.SourceSpanKey) &&
(k != RT.LineKey) &&
(k != RT.ColumnKey))
return true;
}
return false;
}
public MetaExpr(Expr expr, MapExpr meta)
{
_expr = expr;
_meta = meta;
}
public static Expr Parse(ParserContext pcon, ISeq form, string name)
{
ISeq origForm = form;
FnExpr fn = new FnExpr(Compiler.TagOf(form));
fn._src = form;
if (((IMeta)form.first()).meta() != null)
{
fn._onceOnly = RT.booleanCast(RT.get(RT.meta(form.first()), KW_ONCE));
}
fn.ComputeNames(form, name);
List <string> prims = new List <string>();
//arglist might be preceded by symbol naming this fn
if (RT.second(form) is Symbol)
{
Symbol nm = (Symbol)RT.second(form);
fn._thisName = nm.Name;
fn._isStatic = false; // RT.booleanCast(RT.get(nm.meta(), Compiler.STATIC_KEY));
form = RT.cons(Compiler.FnSym, RT.next(RT.next(form)));
}
// Normalize body
//now (fn [args] body...) or (fn ([args] body...) ([args2] body2...) ...)
//turn former into latter
if (RT.second(form) is IPersistentVector)
{
form = RT.list(Compiler.FnSym, RT.next(form));
}
fn.SpanMap = (IPersistentMap)Compiler.SourceSpanVar.deref();
GenContext newContext = null;
GenContext context = Compiler.CompilerContextVar.deref() as GenContext ?? Compiler.EvalContext;
newContext = context.WithNewDynInitHelper(fn.InternalName + "__dynInitHelper_" + RT.nextID().ToString());
Var.pushThreadBindings(RT.map(Compiler.CompilerContextVar, newContext));
try
{
try
{
Var.pushThreadBindings(RT.mapUniqueKeys(
Compiler.ConstantsVar, PersistentVector.EMPTY,
Compiler.ConstantIdsVar, new IdentityHashMap(),
Compiler.KeywordsVar, PersistentHashMap.EMPTY,
Compiler.VarsVar, PersistentHashMap.EMPTY,
Compiler.KeywordCallsitesVar, PersistentVector.EMPTY,
Compiler.ProtocolCallsitesVar, PersistentVector.EMPTY,
Compiler.VarCallsitesVar, Compiler.EmptyVarCallSites(),
Compiler.NoRecurVar, null));
SortedDictionary <int, FnMethod> methods = new SortedDictionary <int, FnMethod>();
FnMethod variadicMethod = null;
for (ISeq s = RT.next(form); s != null; s = RT.next(s))
{
FnMethod f = FnMethod.Parse(fn, (ISeq)RT.first(s), fn._isStatic);
if (f.IsVariadic)
{
if (variadicMethod == null)
{
variadicMethod = f;
}
else
{
throw new ParseException("Can't have more than 1 variadic overload");
}
}
else if (!methods.ContainsKey(f.RequiredArity))
{
methods[f.RequiredArity] = f;
}
else
{
throw new ParseException("Can't have 2 overloads with the same arity.");
}
if (f.Prim != null)
{
prims.Add(f.Prim);
}
}
if (variadicMethod != null && methods.Count > 0 && methods.Keys.Max() >= variadicMethod.NumParams)
{
throw new ParseException("Can't have fixed arity methods with more params than the variadic method.");
}
if (fn._isStatic && fn.Closes.count() > 0)
{
throw new ParseException("static fns can't be closures");
}
IPersistentCollection allMethods = null;
foreach (FnMethod method in methods.Values)
{
allMethods = RT.conj(allMethods, method);
}
if (variadicMethod != null)
{
allMethods = RT.conj(allMethods, variadicMethod);
}
fn._methods = allMethods;
fn._variadicMethod = variadicMethod;
fn.Keywords = (IPersistentMap)Compiler.KeywordsVar.deref();
fn.Vars = (IPersistentMap)Compiler.VarsVar.deref();
fn.Constants = (PersistentVector)Compiler.ConstantsVar.deref();
fn.KeywordCallsites = (IPersistentVector)Compiler.KeywordCallsitesVar.deref();
fn.ProtocolCallsites = (IPersistentVector)Compiler.ProtocolCallsitesVar.deref();
fn.VarCallsites = (IPersistentSet)Compiler.VarCallsitesVar.deref();
fn._constantsID = RT.nextID();
}
finally
{
Var.popThreadBindings();
}
IPersistentMap fmeta = RT.meta(origForm);
if (fmeta != null)
{
fmeta = fmeta.without(RT.LineKey).without(RT.ColumnKey).without(RT.SourceSpanKey).without(RT.FileKey);
}
fn._hasMeta = RT.count(fmeta) > 0;
IPersistentVector primTypes = PersistentVector.EMPTY;
foreach (string typename in prims)
{
primTypes = primTypes.cons(Type.GetType(typename));
}
fn.Compile(
fn.IsVariadic ? typeof(RestFn) : typeof(AFunction),
null,
primTypes,
fn._onceOnly,
newContext);
if (fn.SupportsMeta)
{
return(new MetaExpr(fn, MapExpr.Parse(pcon.EvalOrExpr(), fmeta)));
}
else
{
return(fn);
}
}
finally
{
if (newContext != null)
{
Var.popThreadBindings();
}
}
}
private bool IncludesExplicitMetadata(MapExpr expr)
{
for(int i=0; i < expr.KeyVals.count(); i += 2)
{
Keyword k = ((KeywordExpr)expr.KeyVals.nth(i)).Kw;
if ((k != RT.FILE_KEY) &&
(k != RT.DECLARED_KEY) &&
(k != RT.SOURCE_SPAN_KEY ) &&
(k != RT.LINE_KEY))
return true;
}
return false;
}
public MetaExpr(Expr expr, MapExpr meta)
{
_expr = expr;
_meta = meta;
}
public static Expr Parse(ParserContext pcon, IPersistentMap form)
{
ParserContext pconToUse = pcon.EvalOrExpr();
bool keysConstant = true;
bool valsConstant = true;
bool allConstantKeysUnique = true;
IPersistentSet constantKeys = PersistentHashSet.EMPTY;
IPersistentVector keyvals = PersistentVector.EMPTY;
for (ISeq s = RT.seq(form); s != null; s = s.next())
{
IMapEntry e = (IMapEntry)s.first();
Expr k = Compiler.Analyze(pconToUse, e.key());
Expr v = Compiler.Analyze(pconToUse, e.val());
keyvals = (IPersistentVector)keyvals.cons(k);
keyvals = (IPersistentVector)keyvals.cons(v);
if (k is LiteralExpr)
{
object kval = k.Eval();
if (constantKeys.contains(kval))
{
allConstantKeysUnique = false;
}
else
{
constantKeys = (IPersistentSet)constantKeys.cons(kval);
}
}
else
{
keysConstant = false;
}
if (!(v is LiteralExpr))
{
valsConstant = false;
}
}
Expr ret = new MapExpr(keyvals);
IObj iobjForm = form as IObj;
if (iobjForm != null && iobjForm.meta() != null)
{
return(Compiler.OptionallyGenerateMetaInit(pcon, form, ret));
}
//else if (constant)
//{
// This 'optimzation' works, mostly, unless you have nested map values.
// The nested map values do not participate in the constants map, so you end up with the code to create the keys.
// Result: huge duplication of keyword creation. 3X increase in init time to the REPL.
// //IPersistentMap m = PersistentHashMap.EMPTY;
// //for (int i = 0; i < keyvals.length(); i += 2)
// // m = m.assoc(((LiteralExpr)keyvals.nth(i)).Val, ((LiteralExpr)keyvals.nth(i + 1)).Val);
// //return new ConstantExpr(m);
// return ret;
//}
else if (keysConstant)
{
// TBD: Add more detail to exception thrown below.
if (!allConstantKeysUnique)
{
throw new ArgumentException("Duplicate constant keys in map");
}
if (valsConstant)
{
// This 'optimzation' works, mostly, unless you have nested map values.
// The nested map values do not participate in the constants map, so you end up with the code to create the keys.
// Result: huge duplication of keyword creation. 3X increase in init time to the REPL.
//IPersistentMap m = PersistentHashMap.EMPTY;
//for (int i = 0; i < keyvals.length(); i += 2)
// m = m.assoc(((LiteralExpr)keyvals.nth(i)).Val, ((LiteralExpr)keyvals.nth(i + 1)).Val);
//return new ConstantExpr(m);
return(ret);
}
else
{
return(ret);
}
}
else
{
return(ret);
}
}
public static Expr Parse(ParserContext pcon, IPersistentMap form)
{
ParserContext pconToUse = pcon.EvEx();
bool constant = true;
IPersistentVector keyvals = PersistentVector.EMPTY;
for (ISeq s = RT.seq(form); s != null; s = s.next())
{
IMapEntry e = (IMapEntry)s.first();
Expr k = Compiler.Analyze(pconToUse, e.key());
Expr v = Compiler.Analyze(pconToUse, e.val());
keyvals = (IPersistentVector)keyvals.cons(k);
keyvals = (IPersistentVector)keyvals.cons(v);
if (!(k is LiteralExpr && v is LiteralExpr))
constant = false;
}
Expr ret = new MapExpr(keyvals);
if (form is IObj && ((IObj)form).meta() != null)
return Compiler.OptionallyGenerateMetaInit(pcon, form, ret);
else if (constant)
{
IPersistentMap m = PersistentHashMap.EMPTY;
for (int i = 0; i < keyvals.length(); i += 2)
m = m.assoc(((LiteralExpr)keyvals.nth(i)).Val, ((LiteralExpr)keyvals.nth(i + 1)).Val);
return new ConstantExpr(m);
}
else
return ret;
}
public static Expr Parse(ParserContext pcon, IPersistentMap form)
{
ParserContext pconToUse = pcon.EvalOrExpr();
bool keysConstant = true;
bool valsConstant = true;
bool allConstantKeysUnique = true;
IPersistentSet constantKeys = PersistentHashSet.EMPTY;
IPersistentVector keyvals = PersistentVector.EMPTY;
for (ISeq s = RT.seq(form); s != null; s = s.next())
{
IMapEntry e = (IMapEntry)s.first();
Expr k = Compiler.Analyze(pconToUse, e.key());
Expr v = Compiler.Analyze(pconToUse, e.val());
keyvals = (IPersistentVector)keyvals.cons(k);
keyvals = (IPersistentVector)keyvals.cons(v);
if (k is LiteralExpr)
{
object kval = k.Eval();
if (constantKeys.contains(kval))
allConstantKeysUnique = false;
else
constantKeys = (IPersistentSet)constantKeys.cons(kval);
}
else
keysConstant = false;
if (!(v is LiteralExpr))
valsConstant = false;
}
Expr ret = new MapExpr(keyvals);
IObj iobjForm = form as IObj;
if (iobjForm != null && iobjForm.meta() != null)
return Compiler.OptionallyGenerateMetaInit(pcon, form, ret);
//else if (constant)
//{
// This 'optimzation' works, mostly, unless you have nested map values.
// The nested map values do not participate in the constants map, so you end up with the code to create the keys.
// Result: huge duplication of keyword creation. 3X increase in init time to the REPL.
// //IPersistentMap m = PersistentHashMap.EMPTY;
// //for (int i = 0; i < keyvals.length(); i += 2)
// // m = m.assoc(((LiteralExpr)keyvals.nth(i)).Val, ((LiteralExpr)keyvals.nth(i + 1)).Val);
// //return new ConstantExpr(m);
// return ret;
//}
else if (keysConstant)
{
// TBD: Add more detail to exception thrown below.
if (!allConstantKeysUnique)
throw new ArgumentException("Duplicate constant keys in map");
if (valsConstant)
{
// This 'optimzation' works, mostly, unless you have nested map values.
// The nested map values do not participate in the constants map, so you end up with the code to create the keys.
// Result: huge duplication of keyword creation. 3X increase in init time to the REPL.
//IPersistentMap m = PersistentArrayMap.EMPTY;
//for (int i = 0; i < keyvals.length(); i += 2)
// m = m.assoc(((LiteralExpr)keyvals.nth(i)).Val, ((LiteralExpr)keyvals.nth(i + 1)).Val);
//return new ConstantExpr(m);
return ret;
}
else
return ret;
}
else
return ret;
}