public NewExpr(Type type, List<HostArg> args, IPersistentMap spanMap) { _args = args; _type = type; _spanMap = spanMap; _ctor = ComputeCtor(); }
public RecurExpr(string source, IPersistentMap spanMap, IPersistentVector loopLocals, IPersistentVector args) { _loopLocals = loopLocals; _args = args; _source = source; _spanMap = spanMap; }
/// <summary> /// Construct a symbol from interned namespace name and symbol name, with given metadata. /// </summary> /// <param name="meta">The metadata to attach.</param> /// <param name="ns_interned">The (interned) namespace name.</param> /// <param name="name_interned">The (interned) symbol name.</param> private Symbol(IPersistentMap meta, string ns_interned, string name_interned) : base(meta) { this._name = name_interned; this._ns = ns_interned; this._hash = ComputeHashCode(); }
public static IPersistentMap ExtractAttributes(IPersistentMap meta) { if (meta != null && EXTRACT_ATTRIBUTES.isBound) return (IPersistentMap)EXTRACT_ATTRIBUTES.invoke(meta); return PersistentArrayMap.EMPTY; }
/// <summary> /// Initialize from given metatadata, plus first, restFn, rest. /// </summary> /// <param name="meta">The metadata to attach</param> /// <param name="first">The first of the sequence.</param> /// <param name="restFn">The function to generate the next value.</param> /// <param name="rest">The rest of the sequence..</param> FnSeq(IPersistentMap meta, object first, IFn restFn, ISeq rest) : base(meta) { _first = first; _restFn = restFn; _rest = rest; }
public IfExpr( IPersistentMap sourceSpan, Expr testExpr, Expr thenExpr, Expr elseExpr) { _sourceSpan = sourceSpan; _testExpr = testExpr; _thenExpr = thenExpr; _elseExpr = elseExpr; }
/// <summary> /// Create a copy with new metadata. /// </summary> /// <param name="meta">The new metadata.</param> /// <returns>A copy of the object with new metadata attached.</returns> public override IObj withMeta(IPersistentMap meta) { // Java doesn't make the identity test: return new Cons(meta, _first, _rest); return (meta == _meta) ? this : new Cons(meta, _first, _more); }
internal static IFn CreateForMetaAlter(IPersistentMap meta) { AFnImpl fn = new AFnImpl(); fn._fn0 = () => { return meta; }; fn._fn1 = (object x) => { return meta; }; return fn; }
internal PersistentList(object first, IPersistentList rest, int count, IPersistentMap metadata) : base(metadata) { this.first = first; this.rest = rest; this.count = count; }
private Keyword(string ns, string name, IPersistentMap metadata) : base(metadata) { this.ns = ns; this.name = name; this.hash = Utilities.CombineHash(name.GetHashCode(), Utilities.Hash(ns)); }
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.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) { // 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 IPersistentList Create(IList list, IPersistentMap metadata) { if (list == null || list.Count == 0) return EmptyList.Instance; return new ListObject(list, 0, metadata); }
/// <summary> /// Construct a <see cref="StreamSeq">StreamSeq</see> from metadata and first/rest. /// </summary> /// <param name="meta">The metadata to attach</param> /// <param name="first">The first item.</param> /// <param name="rest">The rest of the sequence.</param> StreamSeq(IPersistentMap meta, Object first, ISeq rest) : base(meta) { _first = first; _rest = rest; _stream = null; }
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; }
/// <summary> /// Initialize a struct from given data. /// </summary> /// <param name="meta">The metadata to attach.</param> /// <param name="def">The structure definition.</param> /// <param name="vals">Values for the fixed keys.</param> /// <param name="ext">Additional keys/values.</param> protected PersistentStructMap(IPersistentMap meta, Def def, Object[] vals, IPersistentMap ext) : base(meta) { _ext = ext; _def = def; _vals = vals; }
/// <summary> /// Initialize a list with given metadata, first element and rest of list. /// </summary> /// <param name="meta">The metadata to attach.</param> /// <param name="first">The first element in the list.</param> /// <param name="rest">The rest of the list.</param> /// <param name="count">The number of elements in the list.</param> PersistentList(IPersistentMap meta, Object first, IPersistentList rest, int count) : base(meta) { this._first = first; this._rest = rest; this._count = count; }
public CaseExpr( IPersistentMap sourceSpan, LocalBindingExpr expr, int shift, int mask, int low, int high, Expr defaultExpr, SortedDictionary<int, Expr> tests, Dictionary<int, Expr> thens, Keyword switchType, Keyword testType, IPersistentSet skipCheck) { _sourceSpan = sourceSpan; _expr = expr; _shift = shift; _mask = mask; //_low = low; //_high = high; _defaultExpr = defaultExpr; _tests = tests; _thens = thens; if (switchType != _compactKey && switchType != _sparseKey) throw new ArgumentException("Unexpected switch type: " + switchType); //_switchType = switchType; if (testType != _intKey && testType != _hashEquivKey && testType != _hashIdentityKey) throw new ArgumentException("Unexpected test type: " + testType); _testType = testType; _skipCheck = skipCheck; ICollection<Expr> returns = new List<Expr>(thens.Values); returns.Add(defaultExpr); _returnType = Compiler.MaybeClrType(returns); if (RT.count(skipCheck) > 0 && RT.booleanCast(RT.WarnOnReflectionVar.deref())) { RT.errPrintWriter().WriteLine("Performance warning, {0}:{1} - hash collision of some case test constants; if selected, those entries will be tested sequentially.", Compiler.SourcePathVar.deref(),RT.get(sourceSpan,RT.StartLineKey)); } }
public override IObject WithMetadata(IPersistentMap metadata) { if (this.Metadata == metadata) return this; return new Cons(this.first, this.rest, metadata); }
#pragma warning restore 414 #endregion #region C-tors public InstanceOfExpr(string source, IPersistentMap spanMap, Type t, Expr expr) { _source = source; _spanMap = spanMap; _t = t; _expr = expr; }
/// <summary> /// Initialize a <see cref="PersistentVector">PersistentVector</see> from basic components. /// </summary> /// <param name="cnt"></param> /// <param name="shift"></param> /// <param name="root"></param> /// <param name="tail"></param> public PersistentVector(int cnt, int shift, Node root, object[] tail) { _meta = null; _cnt = cnt; _shift = shift; _root = root; _tail = tail; }
private PersistentVector(IPersistentMap metadata, List<object[]> root, object[] tail) : base(metadata) { this.root = root; this.tail = tail; this.count = (tail == null ? 0 : tail.Length) + (root == null ? 0 : root.Count * NodeSize); }
public ExceptionInfo(String s, IPersistentMap data, Exception innerException) : base(s, innerException) { if (data != null) this.data = data; else throw new ArgumentException("Additional data must be non-nil.", "data"); }
protected MethodExpr(string source, IPersistentMap spanMap, Symbol tag, string methodName, List<HostArg> args) { _source = source; _spanMap = spanMap; _methodName = methodName; _args = args; _tag = tag; }
private EnumeratorSequence(IEnumerator enumerator, object first, ISequence rest, IPersistentMap metadata) : base(metadata) { this.enumerator = enumerator; this.first = first; this.rest = rest; this.restWasCalculated = true; }
/// <summary> /// Construct a symbol from interned namespace name and symbol name. /// </summary> /// <param name="ns_interned">The (interned) namespace name.</param> /// <param name="name_interned">The (interned) symbol name.</param> private Symbol(string ns_interned, string name_interned) : base() { _meta = null; _name = name_interned; _ns = ns_interned; _hash = ComputeHashCode(); }
/// <summary> /// Initialize a <see cref="PersistentHashMap">PersistentHashMap</see> with a given count and root node. /// </summary> /// <param name="count">The count.</param> /// <param name="root">The root node.</param> /// <param name="hasNull"></param> /// <param name="nullValue"></param> PersistentHashMap(int count, INode root, bool hasNull, object nullValue) { _meta = null; _count = count; _root = root; _hasNull = hasNull; _nullValue = nullValue; }
/// <summary> /// Initialize a <see cref="PersistentVector">PersistentVector</see> from given metadata and basic components. /// </summary> /// <param name="meta"></param> /// <param name="cnt"></param> /// <param name="shift"></param> /// <param name="root"></param> /// <param name="tail"></param> PersistentVector(IPersistentMap meta, int cnt, int shift, Node root, object[] tail) { _meta = meta; _cnt = cnt; _shift = shift; _root = root; _tail = tail; }
ArraySeq(IPersistentMap meta, object array, int i) : base(meta) { _a = array; _i = i; _oa = (object[])(array is object[] ? array : null); _ilist = (IList)_a; }
private Cycle(IPersistentMap meta, ISeq all, ISeq prev, ISeq current, ISeq next) :base(meta) { _all = all; _prev = prev; _current = current; _next = next; }
/// <summary> /// Initialize a <see cref="PersistentHashSet">PersistentHashSet</see> to use given metadata and underlying map. /// </summary> /// <param name="meta">The metadata to attach.</param> /// <param name="impl">The implementating map.</param> PersistentHashSet(IPersistentMap meta, IPersistentMap impl) : base(meta, impl) { }
/// <summary> /// Get the method for a dispatch value and cache it. /// </summary> /// <param name="dispatchVal">The disaptch value.</param> /// <returns>The mest method.</returns> private IFn FindAndCacheBestMethod(object dispatchVal) { _rw.EnterWriteLock(); object bestValue; IPersistentMap mt = _methodTable; IPersistentMap pt = _preferTable; object ch = _cachedHierarchy; try { IMapEntry bestEntry = null; foreach (IMapEntry me in MethodTable) { if (IsA(dispatchVal, me.key())) { if (bestEntry == null || Dominates(me.key(), bestEntry.key())) { bestEntry = me; } if (!Dominates(bestEntry.key(), me.key())) { throw new ArgumentException(String.Format("Multiple methods in multimethod {0} match dispatch value: {1} -> {2} and {3}, and neither is preferred", _name, dispatchVal, me.key(), bestEntry.key())); } } } if (bestEntry == null) { bestValue = _methodTable.valAt(_defaultDispatchVal); if (bestValue == null) { return(null); } } else { bestValue = bestEntry.val(); } } finally { _rw.ExitWriteLock(); } // ensure basis has stayed stable throughout, else redo _rw.EnterWriteLock(); try { if (mt == _methodTable && pt == _preferTable && ch == _cachedHierarchy && _cachedHierarchy == _hierarchy.deref()) { // place in cache _methodCache = _methodCache.assoc(dispatchVal, bestValue); return((IFn)bestValue); } else { ResetCache(); return(FindAndCacheBestMethod(dispatchVal)); } } finally { _rw.ExitWriteLock(); } }
/// <summary> /// Initializes an <see cref="ASeq">ASeq</see> with given metadata. /// </summary> /// <param name="meta"></param> protected ASeq(IPersistentMap meta) : base(meta) { }
/// <summary> /// Create a copy with new metadata. /// </summary> /// <param name="meta">The new metadata.</param> /// <returns>A copy of the object with new metadata attached.</returns> public IObj withMeta(IPersistentMap meta) { return(meta == _meta ? this : new PersistentTreeSet(meta, _impl)); }
public IObj withMeta(IPersistentMap meta) { // Java version does not do identity check return(new PersistentVector(meta, _cnt, _shift, _root, _tail)); }
protected AFunctionMeta(IPersistentMap meta) { _meta = meta; }
public Expr Parse(ParserContext pcon, object form) { // (def x) or (def x initexpr) or (def x "docstring" initexpr) string docstring = null; if (RT.count(form) == 4 && (RT.third(form) is String)) { docstring = (String)RT.third(form); form = RT.list(RT.first(form), RT.second(form), RT.fourth(form)); } if (RT.count(form) > 3) { throw new ParseException("Too many arguments to def"); } if (RT.count(form) < 2) { throw new ParseException("Too few arguments to def"); } Symbol sym = RT.second(form) as Symbol; if (sym == null) { throw new ParseException("First argument to def must be a Symbol."); } //Console.WriteLine("Def {0}", sym.Name); Var v = Compiler.LookupVar(sym, true); if (v == null) { throw new ParseException("Can't refer to qualified var that doesn't exist"); } if (!v.Namespace.Equals(Compiler.CurrentNamespace)) { if (sym.Namespace == null) { v = Compiler.CurrentNamespace.intern(sym); } //throw new Exception(string.Format("Name conflict, can't def {0} because namespace: {1} refers to: {2}", // sym, Compiler.CurrentNamespace.Name, v)); else { throw new ParseException("Can't create defs outside of current namespace"); } } IPersistentMap mm = sym.meta(); bool isDynamic = RT.booleanCast(RT.get(mm, Compiler.DynamicKeyword)); if (isDynamic) { v.setDynamic(); } if (!isDynamic && sym.Name.StartsWith("*") && sym.Name.EndsWith("*") && sym.Name.Length > 1) { RT.errPrintWriter().WriteLine("Warning: {0} not declared dynamic and thus is not dynamically rebindable, " + "but its name suggests otherwise. Please either indicate ^:dynamic {0} or change the name. ({1}:{2}\n", sym, Compiler.SourcePathVar.get(), Compiler.LineVar.get()); } if (RT.booleanCast(RT.get(mm, Compiler.ArglistsKeyword))) { IPersistentMap vm = v.meta(); //vm = (IPersistentMap)RT.assoc(vm, Compiler.STATIC_KEY, true); // drop quote vm = (IPersistentMap)RT.assoc(vm, Compiler.ArglistsKeyword, RT.second(mm.valAt(Compiler.ArglistsKeyword))); v.setMeta(vm); } Object source_path = Compiler.SourcePathVar.get(); source_path = source_path ?? "NO_SOURCE_FILE"; mm = (IPersistentMap)RT.assoc(mm, RT.LineKey, Compiler.LineVar.get()) .assoc(RT.ColumnKey, Compiler.ColumnVar.get()) .assoc(RT.FileKey, source_path); //.assoc(RT.SOURCE_SPAN_KEY,Compiler.SOURCE_SPAN.deref()); if (docstring != null) { mm = (IPersistentMap)RT.assoc(mm, RT.DocKey, docstring); } // Following comment in JVM version //mm = mm.without(RT.DOC_KEY) // .without(Keyword.intern(null, "arglists")) // .without(RT.FILE_KEY) // .without(RT.LINE_KEY) // .without(RT.COLUMN_KEY) // .without(Keyword.intern(null, "ns")) // .without(Keyword.intern(null, "name")) // .without(Keyword.intern(null, "added")) // .without(Keyword.intern(null, "static")); mm = (IPersistentMap)Compiler.ElideMeta(mm); Expr meta = mm == null || mm.count() == 0 ? null : Compiler.Analyze(pcon.EvalOrExpr(), mm); Expr init = Compiler.Analyze(pcon.EvalOrExpr(), RT.third(form), v.Symbol.Name); bool initProvided = RT.count(form) == 3; return(new DefExpr( (string)Compiler.SourceVar.deref(), (int)Compiler.LineVar.deref(), (int)Compiler.ColumnVar.deref(), v, init, meta, initProvided, isDynamic)); }
public void SetLocals(IPersistentMap locals, IPersistentMap indexLocals) { Locals = locals; IndexLocals = indexLocals; }
/// <summary> /// Create a copy with new metadata. /// </summary> /// <param name="meta">The new metadata.</param> /// <returns>A copy of the object with new metadata attached.</returns> public override IObj withMeta(IPersistentMap meta) { return(meta == _meta ? this : new PersistentArrayMap(meta, _array)); }
public ArraySeq_sbyte(IPersistentMap meta, sbyte[] array, int index) : base(meta, array, index) { }
public NumericArraySeq(IPersistentMap meta, T[] array, int index) : base(meta, array, index) { }
public override IObj withMeta(IPersistentMap meta) { return(DuplicateWithMeta(meta)); }
public InstancePropertyExpr(string source, IPersistentMap spanMap, Symbol tag, Expr target, string propertyName, PropertyInfo pinfo) : base(source, spanMap, tag, target, propertyName, pinfo) { }
public override IObj withMeta(IPersistentMap meta) { return((meta == _meta) ? this : new ChunkedSeq(meta, _vec, _node, _i, _offset)); }
public override IObj withMeta(IPersistentMap meta) { throw new NotImplementedException(); }
public InstanceFieldExpr(string source, IPersistentMap spanMap, Symbol tag, Expr target, string fieldName, FieldInfo finfo) : base(source, spanMap, tag, target, fieldName, finfo) { }
static public void EmitDynamicCallPreamble(DynamicExpression dyn, IPersistentMap spanMap, string methodName, Type returnType, IList <ParameterExpression> paramExprs, Type[] paramTypes, CljILGen ilg, out LambdaExpression lambda, out Type delType, out MethodBuilder mbLambda) { Expression call = dyn; GenContext context = Compiler.CompilerContextVar.deref() as GenContext; DynInitHelper.SiteInfo siteInfo; if (context != null && context.DynInitHelper != null) { call = context.DynInitHelper.ReduceDyn(dyn, out siteInfo); } else { throw new InvalidOperationException("Don't know how to handle callsite in this case"); } if (returnType == typeof(void)) { call = Expression.Block(call, Expression.Default(typeof(object))); returnType = typeof(object); } else if (returnType != call.Type) { call = Expression.Convert(call, returnType); } call = GenContext.AddDebugInfo(call, spanMap); delType = Microsoft.Scripting.Generation.Snippets.Shared.DefineDelegate("__interop__", returnType, paramTypes); lambda = Expression.Lambda(delType, call, paramExprs); mbLambda = null; if (context == null) { // light compile Delegate d = lambda.Compile(); int key = RT.nextID(); CacheDelegate(key, d); ilg.EmitInt(key); ilg.Emit(OpCodes.Call, Method_MethodExpr_GetDelegate); ilg.Emit(OpCodes.Castclass, delType); } else { mbLambda = context.TB.DefineMethod(methodName, MethodAttributes.Static | MethodAttributes.Public, CallingConventions.Standard, returnType, paramTypes); //lambda.CompileToMethod(mbLambda); // Now we get to do all this code create by hand. // the primary code is // (loc1 = fb).Target.Invoke(loc1,*args); // if return type if void, pop the value and push a null // if return type does not match the call site, add a conversion CljILGen ilg2 = new CljILGen(mbLambda.GetILGenerator()); ilg2.EmitFieldGet(siteInfo.FieldBuilder); ilg2.Emit(OpCodes.Dup); LocalBuilder siteVar = ilg2.DeclareLocal(siteInfo.DelegateType); ilg2.Emit(OpCodes.Stloc, siteVar); ilg2.EmitFieldGet(siteInfo.SiteType.GetField("Target")); ilg2.Emit(OpCodes.Ldloc, siteVar); for (int i = 0; i < paramExprs.Count; i++) { ilg2.EmitLoadArg(i); } ilg2.EmitCall(siteInfo.DelegateType.GetMethod("Invoke")); if (returnType == typeof(void)) { ilg2.Emit(OpCodes.Pop); ilg2.EmitNull(); } else if (returnType != call.Type) { EmitConvertToType(ilg2, call.Type, returnType, false); } ilg2.Emit(OpCodes.Ret); /* * return Expression.Block( * new[] { site }, * Expression.Call( * Expression.Field( * Expression.Assign(site, access), * cs.GetType().GetField("Target") * ), * node.DelegateType.GetMethod("Invoke"), * ClrExtensions.ArrayInsert(site, node.Arguments) * ) */ } }
public AFunctionMeta() { _meta = null; }
private static void EmitExposers(TypeBuilder proxyTB, Type superClass, IPersistentMap exposesFields) { for (ISeq s = RT.seq(exposesFields); s != null; s = s.next()) { IMapEntry me = (IMapEntry)s.first(); Symbol protectedFieldSym = (Symbol)me.key(); IPersistentMap accessMap = (IPersistentMap)me.val(); string fieldName = protectedFieldSym.Name; Symbol getterSym = (Symbol)accessMap.valAt(_getKw, null); Symbol setterSym = (Symbol)accessMap.valAt(_setKW, null); FieldInfo fld = null; if (getterSym != null || setterSym != null) { fld = superClass.GetField(fieldName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy | BindingFlags.Static | BindingFlags.Instance); } if (getterSym != null) { MethodAttributes attribs = MethodAttributes.Public; if (fld.IsStatic) { attribs |= MethodAttributes.Static; } MethodBuilder mb = proxyTB.DefineMethod(getterSym.Name, attribs, fld.FieldType, Type.EmptyTypes); CljILGen gen = new CljILGen(mb.GetILGenerator()); //if (fld.IsStatic) // gen.Emit(OpCodes.Ldsfld, fld); //else //{ // gen.Emit(OpCodes.Ldarg_0); // gen.Emit(OpCodes.Ldfld, fld); //} if (!fld.IsStatic) { gen.EmitLoadArg(0); } gen.EmitFieldGet(fld); gen.Emit(OpCodes.Ret); } if (setterSym != null) { MethodAttributes attribs = MethodAttributes.Public; if (fld.IsStatic) { attribs |= MethodAttributes.Static; } MethodBuilder mb = proxyTB.DefineMethod(setterSym.Name, attribs, typeof(void), new Type[] { fld.FieldType }); CljILGen gen = new CljILGen(mb.GetILGenerator()); if (fld.IsStatic) { gen.Emit(OpCodes.Ldarg_0); //gen.Emit(OpCodes.Stsfld, fld); } else { gen.Emit(OpCodes.Ldarg_0); gen.Emit(OpCodes.Ldarg_1); //gen.Emit(OpCodes.Stfld, fld); } gen.EmitFieldSet(fld); gen.Emit(OpCodes.Ret); } } }
/// <summary> /// Initialize a <see cref="PersistentTreeSet">PersistentTreeSet</see> using given metadata and underlying implementation map. /// </summary> /// <param name="meta">The metadata to attach</param> /// <param name="impl">A map to implement the set.</param> PersistentTreeSet(IPersistentMap meta, IPersistentMap impl) : base(impl) { _meta = meta; }
static void DefineCtors(TypeBuilder proxyTB, Type superClass, string initName, string postInitName, ISeq ctors, ISeq ctorTypes, FieldBuilder initFB, FieldBuilder postInitFB, FieldBuilder stateFB, string factoryName) { ISeq s1 = ctors; for (ISeq s = ctorTypes; s != null; s = s.next()) { // TODO: Get rid of this mess by making sure the metadata on the keys of the constructors map gets copied to the constructor-types map. Sigh. IPersistentMap ctorAttributes = GenInterface.ExtractAttributes(RT.meta(((IMapEntry)s1.first()).key())); s1 = s1.next(); IMapEntry me = (IMapEntry)s.first(); ISeq thisParamTypesV = (ISeq)me.key(); ISeq baseParamTypesV = (ISeq)me.val(); Type[] thisParamTypes = CreateTypeArray(thisParamTypesV); Type[] baseParamTypes = CreateTypeArray(baseParamTypesV); BindingFlags flags = BindingFlags.CreateInstance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance; ConstructorInfo superCtor = superClass.GetConstructor(flags, null, baseParamTypes, null); if (superCtor == null || superCtor.IsPrivate) { throw new InvalidOperationException("Base class constructor missing or private"); } ConstructorBuilder cb = proxyTB.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis, thisParamTypes); GenInterface.SetCustomAttributes(cb, ctorAttributes); CljILGen gen = new CljILGen(cb.GetILGenerator()); Label noInitLabel = gen.DefineLabel(); Label noPostInitLabel = gen.DefineLabel(); Label endPostInitLabel = gen.DefineLabel(); Label endLabel = gen.DefineLabel(); LocalBuilder locSuperArgs = gen.DeclareLocal(typeof(object)); LocalBuilder locInitVal = gen.DeclareLocal(typeof(object)); if (initFB != null) { // init supplied EmitGetVar(gen, initFB); gen.Emit(OpCodes.Dup); gen.Emit(OpCodes.Brfalse_S, noInitLabel); gen.Emit(OpCodes.Castclass, typeof(IFn)); // box init args for (int i = 0; i < thisParamTypes.Length; i++) { gen.EmitLoadArg(i + 1); // gen.Emit(OpCodes.Ldarg, i + 1); if (thisParamTypes[i].IsValueType) { gen.Emit(OpCodes.Box, thisParamTypes[i]); } } gen.EmitCall(Compiler.Methods_IFn_invoke[thisParamTypes.Length]); // gen.Emit(OpCodes.Call, Compiler.Methods_IFn_invoke[thisParamTypes.Length]); // Expecting: [[super-ctor-args...] state] // store the init return in a local gen.Emit(OpCodes.Dup); gen.Emit(OpCodes.Stloc, locInitVal); // store the first element in a local gen.EmitInt(0); // gen.Emit(OpCodes.Ldc_I4_0); gen.EmitCall(Method_RT_nth); // gen.Emit(OpCodes.Call, Method_RT_nth); gen.Emit(OpCodes.Stloc, locSuperArgs); // Stack this + super-ctor-args + call base-class ctor. gen.EmitLoadArg(0); // gen.Emit(OpCodes.Ldarg_0); for (int i = 0; i < baseParamTypes.Length; i++) { gen.Emit(OpCodes.Ldloc, locSuperArgs); gen.EmitInt(i); // gen.Emit(OpCodes.Ldc_I4, i); gen.EmitCall(Method_RT_nth); // gen.Emit(OpCodes.Call, Method_RT_nth); if (baseParamTypes[i].IsValueType) { gen.Emit(OpCodes.Unbox_Any, baseParamTypes[i]); } else { gen.Emit(OpCodes.Castclass, baseParamTypes[i]); } } gen.Emit(OpCodes.Call, superCtor); if (stateFB != null) { gen.EmitLoadArg(0); // gen.Emit(OpCodes.Ldarg_0); gen.Emit(OpCodes.Ldloc, locInitVal); gen.EmitInt(1); // gen.Emit(OpCodes.Ldc_I4_1); gen.EmitCall(Method_RT_nth); // gen.Emit(OpCodes.Call, Method_RT_nth); gen.Emit(OpCodes.Castclass, typeof(object)); gen.EmitFieldSet(stateFB); // gen.Emit(OpCodes.Stfld, stateFB); } gen.Emit(OpCodes.Br_S, endLabel); // No init found gen.MarkLabel(noInitLabel); gen.Emit(OpCodes.Pop); EmitUnsupported(gen, initName); gen.MarkLabel(endLabel); } else // no InitFB supplied. { bool ok = thisParamTypes.Length == baseParamTypes.Length; for (int i = 0; ok && i < thisParamTypes.Length; i++) { ok = baseParamTypes[i].IsAssignableFrom(thisParamTypes[i]); } if (!ok) { throw new InvalidOperationException(":init not specified, but ctor and super ctor args differ"); } gen.EmitLoadArg(0); // gen.Emit(OpCodes.Ldarg_0); for (int i = 0; i < thisParamTypes.Length; i++) { gen.EmitLoadArg(i + 1); // gen.Emit(OpCodes.Ldarg, i + 1); if (baseParamTypes[i] != thisParamTypes[i]) { gen.Emit(OpCodes.Castclass, baseParamTypes[i]); } } gen.Emit(OpCodes.Call, superCtor); } if (postInitFB != null) { // post-init supplied EmitGetVar(gen, postInitFB); gen.Emit(OpCodes.Dup); gen.Emit(OpCodes.Brfalse_S, noPostInitLabel); gen.Emit(OpCodes.Castclass, typeof(IFn)); // box init args gen.EmitLoadArg(0); // gen.Emit(OpCodes.Ldarg_0); for (int i = 0; i < thisParamTypes.Length; i++) { gen.EmitLoadArg(i + 1); // gen.Emit(OpCodes.Ldarg, i + 1); if (thisParamTypes[i].IsValueType) { gen.Emit(OpCodes.Box, thisParamTypes[i]); } gen.Emit(OpCodes.Castclass, thisParamTypes[i]); } gen.EmitCall(Compiler.Methods_IFn_invoke[thisParamTypes.Length + 1]); // gen.Emit(OpCodes.Call, Compiler.Methods_IFn_invoke[thisParamTypes.Length + 1]); gen.Emit(OpCodes.Pop); gen.Emit(OpCodes.Br_S, endPostInitLabel); // no post-init found gen.MarkLabel(noPostInitLabel); gen.Emit(OpCodes.Pop); EmitUnsupported(gen, postInitName + " not defined"); gen.MarkLabel(endPostInitLabel); } gen.Emit(OpCodes.Ret); if (!String.IsNullOrEmpty(factoryName)) { MethodBuilder factoryMB = proxyTB.DefineMethod(factoryName, MethodAttributes.Public | MethodAttributes.Static, CallingConventions.Standard, proxyTB, thisParamTypes); CljILGen genf = new CljILGen(factoryMB.GetILGenerator()); LocalBuilder[] locals = new LocalBuilder[thisParamTypes.Length]; for (int i = 0; i < thisParamTypes.Length; i++) { locals[i] = genf.DeclareLocal(thisParamTypes[i]); genf.EmitLoadArg(i); // genf.Emit(OpCodes.Ldarg, i); genf.Emit(OpCodes.Stloc, locals[i]); } for (int i = 0; i < thisParamTypes.Length; i++) { genf.EmitLoadArg(i); // genf.Emit(OpCodes.Ldarg, i); } genf.EmitNew(cb); // genf.Emit(OpCodes.Newobj, cb); genf.Emit(OpCodes.Ret); } } }
public static Type GenerateClass(string className, Type superClass, ISeq interfaces, // of Types ISeq ctors, ISeq ctorTypes, ISeq methods, IPersistentMap exposesFields, IPersistentMap exposesMethods, string prefix, bool hasMain, string factoryName, string stateName, string initName, string postInitName, string implCname, string implNamespace, bool loadImplNamespace) { className = className.Replace('-', '_'); string path = (string)Compiler.CompilePathVar.deref(); if (path == null) { throw new InvalidOperationException("*compile-path* not set"); } string extension = hasMain ? ".exe" : ".dll"; GenContext context = GenContext.CreateWithExternalAssembly(Compiler.munge(path == "." ? className : path + "/" + className), extension, true); // define the class List <Type> interfaceTypes = new List <Type>(); for (ISeq s = interfaces; s != null; s = s.next()) { interfaceTypes.Add((Type)s.first()); } TypeBuilder proxyTB = context.ModuleBuilder.DefineType( className, TypeAttributes.Class | TypeAttributes.Public, superClass, interfaceTypes.ToArray()); List <MethodSignature> sigs = GetAllSignatures(superClass, interfaceTypes, methods); Dictionary <string, List <MethodSignature> > overloads = ComputeOverloads(sigs); HashSet <string> varNames = ComputeOverloadNames(overloads); foreach (MethodSignature sig in sigs) { varNames.Add(sig.Name); } if (!String.IsNullOrEmpty(initName)) { varNames.Add(initName); } if (!String.IsNullOrEmpty(postInitName)) { varNames.Add(postInitName); } if (hasMain) { varNames.Add(_mainName); } Dictionary <string, FieldBuilder> varMap = DefineStaticFields(proxyTB, varNames); FieldBuilder stateFB = String.IsNullOrEmpty(stateName) ? null : DefineStateField(proxyTB, stateName); DefineStaticCtor(proxyTB, prefix, varMap, loadImplNamespace, implNamespace, implCname); FieldBuilder initFB = null; FieldBuilder postInitFB = null; FieldBuilder mainFB = null; varMap.TryGetValue(initName, out initFB); varMap.TryGetValue(postInitName, out postInitFB); varMap.TryGetValue(_mainName, out mainFB); DefineCtors(proxyTB, superClass, implNamespace + "." + prefix + initName, implNamespace + "." + prefix + postInitName, ctorTypes, initFB, postInitFB, stateFB, factoryName); EmitMethods(proxyTB, sigs, overloads, varMap, exposesMethods); EmitExposers(proxyTB, superClass, exposesFields); if (hasMain) { EmitMain(context, proxyTB, implNamespace + "." + prefix + _mainName, mainFB); } Type t = proxyTB.CreateType(); context.SaveAssembly(); return(t); }
/// <summary> /// Initialize the sequence with given metatdata and array/index. /// </summary> /// <param name="meta">The metadata to attach.</param> /// <param name="array">The array being sequenced over.</param> /// <param name="i">The current index.</param> public Seq(IPersistentMap meta, object[] array, int i) : base(meta) { _array = array; _i = i; }
private static void EmitMethods(TypeBuilder proxyTB, List <MethodSignature> sigs, Dictionary <string, List <MethodSignature> > overloads, Dictionary <string, FieldBuilder> varMap, IPersistentMap exposesMethods) { foreach (MethodSignature sig in sigs) { FieldBuilder regularFB = varMap[sig.Name]; FieldBuilder overloadFB = null; if (overloads.ContainsKey(sig.Name)) { overloadFB = varMap[OverloadName(sig)]; } switch (sig.Source) { case "super": EmitForwardingMethod(proxyTB, false, regularFB, overloadFB, sig, delegate(CljILGen gen) { gen.EmitLoadArg(0); // gen.Emit(OpCodes.Ldarg_0); for (int i = 0; i < sig.ParamTypes.Length; i++) { gen.EmitLoadArg(i + 1); // gen.Emit(OpCodes.Ldarg, (i + 1)); } gen.Emit(OpCodes.Call, sig.Method); // not gen.EmitCall(sig.Method) -- we need call versus callvirt }); break; case "interface": EmitForwardingMethod(proxyTB, false, regularFB, overloadFB, sig, delegate(CljILGen gen) { EmitUnsupported(gen, sig.Name); }); break; default: EmitForwardingMethod(proxyTB, sig.IsStatic, regularFB, overloadFB, sig, delegate(CljILGen gen) { EmitUnsupported(gen, sig.Name); }); break; } } if (exposesMethods != null) { foreach (MethodSignature sig in sigs) { if (sig.Source == "super") { Symbol name = Symbol.intern(sig.Name); if (exposesMethods.containsKey(name)) { CreateSuperCall(proxyTB, (Symbol)exposesMethods.valAt(name), sig.Method); } } } } }
public ConcreteAReference(IPersistentMap meta) : base(meta) { }
public static Expr Parse(ParserContext pcon, ISeq form, string name) { ISeq origForm = form; FnExpr fn = new FnExpr(Compiler.TagOf(form)); fn.Src = form; Keyword retKey = Keyword.intern(null, "rettag"); // TODO: make static object retTag = RT.get(RT.meta(form), retKey); ObjMethod enclosingMethod = (ObjMethod)Compiler.MethodVar.deref(); fn._hasEnclosingMethod = enclosingMethod != null; 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 Symbol nm = RT.second(form) as Symbol; if (nm != null) { fn.ThisName = nm.Name; 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; bool usesThis = false; for (ISeq s = RT.next(form); s != null; s = RT.next(s)) { FnMethod f = FnMethod.Parse(fn, (ISeq)RT.first(s), retTag); if (f.UsesThis) { //Console.WriteLine("{0} uses this",fn.Name); usesThis = true; } 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."); } fn.CanBeDirect = !fn._hasEnclosingMethod && fn.Closes.count() == 0 && !usesThis; IPersistentCollection allMethods = null; foreach (FnMethod method in methods.Values) { allMethods = RT.conj(allMethods, method); } if (variadicMethod != null) { allMethods = RT.conj(allMethods, variadicMethod); } if (fn.CanBeDirect) { for (ISeq s = RT.seq(allMethods); s != null; s = s.next()) { FnMethod fm = s.first() as FnMethod; if (fm.Locals != null) { for (ISeq sl = RT.seq(RT.keys(fm.Locals)); sl != null; sl = sl.next()) { LocalBinding lb = sl.first() as LocalBinding; if (lb.IsArg) { lb.Index -= 1; } } } } } 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).without(retKey); } 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(); } } }
protected void EmitValue(object value, CljILGen ilg) { bool partial = true; if (value == null) { ilg.Emit(OpCodes.Ldnull); } else if (value is String) { ilg.Emit(OpCodes.Ldstr, (String)value); } else if (value is Boolean) { ilg.EmitBoolean((Boolean)value); ilg.Emit(OpCodes.Box, typeof(bool)); } else if (value is Int32) { ilg.EmitInt((int)value); ilg.Emit(OpCodes.Box, typeof(int)); } else if (value is Int64) { ilg.EmitLong((long)value); ilg.Emit(OpCodes.Box, typeof(long)); } else if (value is Double) { ilg.EmitDouble((double)value); ilg.Emit(OpCodes.Box, typeof(double)); } else if (value is Char) { ilg.EmitChar((char)value); ilg.Emit(OpCodes.Box, typeof(char)); } else if (value is Type) { Type t = (Type)value; if (t.IsValueType) { ilg.EmitType(t); } else { //ilg.EmitString(Compiler.DestubClassName(((Type)value).FullName)); ilg.EmitString(((Type)value).FullName); ilg.EmitCall(Compiler.Method_RT_classForName); } } else if (value is Symbol) { Symbol sym = (Symbol)value; if (sym.Namespace == null) { ilg.EmitNull(); } else { ilg.EmitString(sym.Namespace); } ilg.EmitString(sym.Name); ilg.EmitCall(Compiler.Method_Symbol_intern2); } else if (value is Keyword) { Keyword keyword = (Keyword)value; if (keyword.Namespace == null) { ilg.EmitNull(); } else { ilg.EmitString(keyword.Namespace); } ilg.EmitString(keyword.Name); ilg.EmitCall(Compiler.Method_RT_keyword); } else if (value is Var) { Var var = (Var)value; ilg.EmitString(var.Namespace.Name.ToString()); ilg.EmitString(var.Symbol.Name.ToString()); ilg.EmitCall(Compiler.Method_RT_var2); } else if (value is IType) { IPersistentVector fields = (IPersistentVector)Reflector.InvokeStaticMethod(value.GetType(), "getBasis", Type.EmptyTypes); for (ISeq s = RT.seq(fields); s != null; s = s.next()) { Symbol field = (Symbol)s.first(); Type k = Compiler.TagType(Compiler.TagOf(field)); object val = Reflector.GetInstanceFieldOrProperty(value, Compiler.munge(field.Name)); EmitValue(val, ilg); if (k.IsPrimitive) { ilg.Emit(OpCodes.Castclass, k); } } ConstructorInfo cinfo = value.GetType().GetConstructors()[0]; ilg.EmitNew(cinfo); } else if (value is IRecord) { //MethodInfo[] minfos = value.GetType().GetMethods(BindingFlags.Static | BindingFlags.Public); EmitValue(PersistentArrayMap.create((IDictionary)value), ilg); MethodInfo createMI = value.GetType().GetMethod("create", BindingFlags.Static | BindingFlags.Public, null, CallingConventions.Standard, new Type[] { typeof(IPersistentMap) }, null); ilg.EmitCall(createMI); } else if (value is IPersistentMap) { IPersistentMap map = (IPersistentMap)value; List <object> entries = new List <object>(map.count() * 2); foreach (IMapEntry entry in map) { entries.Add(entry.key()); entries.Add(entry.val()); } EmitListAsObjectArray(entries, ilg); ilg.EmitCall(Compiler.Method_RT_map); } else if (value is IPersistentVector) { IPersistentVector args = (IPersistentVector)value; if (args.count() <= Tuple.MAX_SIZE) { for (int i = 0; i < args.count(); i++) { EmitValue(args.nth(i), ilg); } ilg.Emit(OpCodes.Call, Compiler.Methods_CreateTuple[args.count()]); } else { EmitListAsObjectArray(value, ilg); ilg.EmitCall(Compiler.Method_RT_vector); } } else if (value is PersistentHashSet) { ISeq vs = RT.seq(value); if (vs == null) { ilg.EmitFieldGet(Compiler.Method_PersistentHashSet_EMPTY); } else { EmitListAsObjectArray(vs, ilg); ilg.EmitCall(Compiler.Method_PersistentHashSet_create); } } else if (value is ISeq || value is IPersistentList) { EmitListAsObjectArray(value, ilg); ilg.EmitCall(Compiler.Method_PersistentList_create); } else if (value is Regex) { ilg.EmitString(((Regex)value).ToString()); ilg.EmitNew(Compiler.Ctor_Regex_1); } else { string cs = null; try { cs = RT.printString(value); } catch (Exception) { throw new InvalidOperationException(String.Format("Can't embed object in code, maybe print-dup not defined: {0}", value)); } if (cs.Length == 0) { throw new InvalidOperationException(String.Format("Can't embed unreadable object in code: " + value)); } if (cs.StartsWith("#<")) { throw new InvalidOperationException(String.Format("Can't embed unreadable object in code: " + cs)); } ilg.EmitString(cs); ilg.EmitCall(Compiler.Method_RT_readString); partial = false; } if (partial) { if (value is IObj && RT.count(((IObj)value).meta()) > 0) { ilg.Emit(OpCodes.Castclass, typeof(IObj)); Object m = ((IObj)value).meta(); EmitValue(Compiler.ElideMeta(m), ilg); ilg.Emit(OpCodes.Castclass, typeof(IPersistentMap)); ilg.Emit(OpCodes.Callvirt, Compiler.Method_IObj_withMeta); } } }
/// <summary> /// Create an empty <see cref="PersistentArrayMap">PersistentArrayMap</see>. /// </summary> protected PersistentArrayMap() { _meta = null; _array = new object[] { }; }
public ArraySeq_ushort(IPersistentMap meta, ushort[] array, int index) : base(meta, array, index) { }
public Expr Parse(ParserContext pcon, object frm) { string source = (string)Compiler.SourceVar.deref(); IPersistentMap spanMap = (IPersistentMap)Compiler.SourceSpanVar.deref(); // Compiler.GetSourceSpanMap(form); ISeq form = (ISeq)frm; IPersistentVector loopLocals = (IPersistentVector)Compiler.LoopLocalsVar.deref(); if (pcon.Rhc != RHC.Return || loopLocals == null) { throw new ParseException("Can only recur from tail position"); } if (Compiler.NoRecurVar.deref() != null) { throw new ParseException("Cannot recur across try"); } IPersistentVector args = PersistentVector.EMPTY; for (ISeq s = RT.seq(form.next()); s != null; s = s.next()) { args = args.cons(Compiler.Analyze(pcon.SetRhc(RHC.Expression).SetAssign(false), s.first())); } if (args.count() != loopLocals.count()) { throw new ParseException(string.Format("Mismatched argument count to recur, expected: {0} args, got {1}", loopLocals.count(), args.count())); } for (int i = 0; i < loopLocals.count(); i++) { LocalBinding lb = (LocalBinding)loopLocals.nth(i); Type primt = lb.PrimitiveType; if (primt != null) { bool mismatch = false; Type pt = Compiler.MaybePrimitiveType((Expr)args.nth(i)); if (primt == typeof(long)) { if (!(pt == typeof(long) || pt == typeof(int) || pt == typeof(short) || pt == typeof(uint) || pt == typeof(ushort) || pt == typeof(ulong) || pt == typeof(char) || pt == typeof(byte) || pt == typeof(sbyte))) { mismatch = true; } } else if (primt == typeof(double)) { if (!(pt == typeof(double) || pt == typeof(float))) { mismatch = true; } } if (mismatch) { lb.RecurMismatch = true; if (RT.booleanCast(RT.WarnOnReflectionVar.deref())) { RT.errPrintWriter().WriteLine("{0}:{1} recur arg for primitive local: {2} is not matching primitive, had: {3}, needed {4}", source, spanMap != null ? (int)spanMap.valAt(RT.StartLineKey, 0) : 0, lb.Name, pt != null ? pt.Name : "Object", primt.Name); } } } } return(new RecurExpr(source, spanMap, loopLocals, args)); }