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 void Emit(RHC rhc, ObjExpr objx, CljILGen ilg) { bool allKeysConstant = true; bool allConstantKeysUnique = true; IPersistentSet constantKeys = PersistentHashSet.EMPTY; for (int i = 0; i < _keyvals.count(); i += 2) { Expr k = (Expr)_keyvals.nth(i); if (k is LiteralExpr) { object kval = k.Eval(); if (constantKeys.contains(kval)) { allConstantKeysUnique = false; } else { constantKeys = (IPersistentSet)constantKeys.cons(kval); } } else { allKeysConstant = false; } } MethodExpr.EmitArgsAsArray(_keyvals, objx, ilg); if ((allKeysConstant && allConstantKeysUnique) || (_keyvals.count() <= 2)) { ilg.EmitCall(Compiler.Method_RT_mapUniqueKeys); } else { ilg.EmitCall(Compiler.Method_RT_map); } if (rhc == RHC.Statement) { ilg.Emit(OpCodes.Pop); } }
public static Expr Parse(ParserContext pcon, IPersistentSet form) { ParserContext pconToUse = pcon.EvalOrExpr(); bool constant = true; IPersistentVector keys = PersistentVector.EMPTY; for (ISeq s = RT.seq(form); s != null; s = s.next()) { object e = s.first(); Expr expr = Compiler.Analyze(pconToUse, e); keys = (IPersistentVector)keys.cons(expr); if (!(expr is LiteralExpr)) { constant = false; } } Expr ret = new SetExpr(keys); IObj iobjForm = form as IObj; if (iobjForm != null && iobjForm.meta() != null) { return(Compiler.OptionallyGenerateMetaInit(pcon, form, ret)); } else if (constant) { IPersistentSet set = PersistentHashSet.EMPTY; for (int i = 0; i < keys.count(); i++) { LiteralExpr ve = (LiteralExpr)keys.nth(i); set = (IPersistentSet)set.cons(ve.Val); } return(new ConstantExpr(set)); } else { return(ret); } }
public void Emit(RHC rhc, ObjExpr objx, CljILGen ilg) { int n = _bindingInits.count(); // Define our locals for (int i = 0; i < n; i++) { BindingInit bi = (BindingInit)_bindingInits.nth(i); LocalBuilder local = ilg.DeclareLocal(typeof(IFn)); bi.Binding.LocalVar = local; ilg.Emit(OpCodes.Ldnull); ilg.Emit(OpCodes.Stloc, local); } // Then initialize IPersistentSet lbset = PersistentHashSet.EMPTY; for (int i = 0; i < n; i++) { BindingInit bi = (BindingInit)_bindingInits.nth(i); lbset = (IPersistentSet)lbset.cons(bi.Binding); bi.Init.Emit(RHC.Expression, objx, ilg); ilg.Emit(OpCodes.Stloc, bi.Binding.LocalVar); } for (int i = 0; i < n; i++) { BindingInit bi = (BindingInit)_bindingInits.nth(i); ObjExpr fe = (ObjExpr)bi.Init; ilg.Emit(OpCodes.Ldloc, bi.Binding.LocalVar); fe.EmitLetFnInits(ilg, bi.Binding.LocalVar, objx, lbset); } _body.Emit(rhc, objx, ilg); }
public static bool IsAssemblyExportable(Assembly assembly, IPersistentSet checkedAssemblies) { if (checkedAssemblies.contains(assembly)) { return(true); } foreach (var referencedAssembly in assembly.GetReferencedAssemblies()) { if (referencedAssembly.Name == "UnityEditor" || referencedAssembly.Name == "Assembly-CSharp-Editor") { return(false); } if (!IsAssemblyExportable(Assembly.Load(referencedAssembly), (IPersistentSet)checkedAssemblies.cons(assembly))) { return(false); } } return(true); }
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); } }