/// <summary>
 /// Construct a namespace with a given name.
 /// </summary>
 /// <param name="name">The name.</param>
 Namespace(Symbol name)
     : base(name.meta())
 {
     _name = name;
     _mappings.Set(RT.DEFAULT_IMPORTS);
     _aliases.Set(RT.map());
 }

        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 static Keyword intern(Symbol sym)
        {
            Keyword k = null;
            WeakReference existingRef = _symKeyMap.Get(sym);
            if (existingRef == null)
            {
                if (sym.meta() != null)
                    sym = (Symbol)sym.withMeta(null);
                k = new Keyword(sym);

                WeakReference wr = new WeakReference(k);
                wr.Target = k;
                existingRef = _symKeyMap.PutIfAbsent(sym, wr);
            }
            if (existingRef == null)
                return k;
            Keyword existingk = (Keyword)existingRef.Target;
            if (existingk != null)
                return existingk;
            // entry died in the interim, do over
            // let's not get confused, remove it.  (else infinite loop).
            _symKeyMap.Remove(sym);
            return intern(sym);
        }

 public DeprecatedWrappingReader(Symbol sym, string macro)
 {
     _sym = sym;
     _macro = macro;
 }

            static object ReadRecord(PushbackTextReader r, Symbol recordName)
            {
                Type recordType = RT.classForName(recordName.ToString());

                char endch;
                bool shortForm = true;

                int ch = r.Read();

                // flush whitespace
                //while (isWhitespace(ch))
                //    ch = r.Read();

                // A defrecord ctor can take two forms.  Check for map->R version first.
                if (ch == '{')
                {
                    endch = '}';
                    shortForm = false;
                }
                else if (ch == '[')
                    endch = ']';
                else
                    throw new ArgumentException(String.Format("Unreadable constructor form starting with \"#{0}{1}\"", recordName, (char)ch));

                object[] recordEntries = ReadDelimitedList(endch, r, true).ToArray();
                object ret = null;
                ConstructorInfo[] allCtors = recordType.GetConstructors();

                if (shortForm)
                {
                    bool ctorFound = false;
                    foreach ( ConstructorInfo cinfo in allCtors )
                        if ( cinfo.GetParameters().Length == recordEntries.Length )
                            ctorFound = true;

                    if ( ! ctorFound )
                        throw new ArgumentException(String.Format("Unexpected number of constructor arguments to {0}: got {1}", recordType.ToString(), recordEntries.Length));

                    ret = Reflector.InvokeConstructor(recordType,recordEntries);
                }
                else
                {
                    IPersistentMap vals = RT.map(recordEntries);
                    for (ISeq s = RT.keys(vals); s != null; s = s.next())
                    {
                        if (!(s.first() is Keyword))
                            throw new ArgumentException(String.Format("Unreadable defrecord form: key must be of type clojure.lang.Keyword, got {0}", s.first().ToString()));
                    }

                    ret = Reflector.InvokeStaticMethod(recordType, "create", new Object[] { vals });
                }

                return ret;
            }

        internal static LocalBinding RegisterLocal(Symbol sym, Symbol tag, Expr init)
        {
            int num = GetAndIncLocalNum();

            LocalBinding b = new LocalBinding(num,sym, tag, init);

            IPersistentMap localsMap = (IPersistentMap)LOCAL_ENV.deref();
            LOCAL_ENV.set(RT.assoc(localsMap,b.Symbol, b));
            FnMethod method = (FnMethod)METHODS.deref();
            method.Locals = (IPersistentMap)RT.assoc(method.Locals,b, b);
            method.IndexLocals = (IPersistentMap)RT.assoc(method.IndexLocals, num, b);
            return b;
        }

 internal static bool NamesStaticMember(Symbol sym)
 {
     return sym.Namespace != null && NamespaceFor(sym) == null;
 }

 // TODO: we have duplicate code below.
 public static Symbol resolveSymbol(Symbol sym)
 {
     //already qualified or classname?
     if (sym.Name.IndexOf('.') > 0)
         return sym;
     if (sym.Namespace != null)
     {
         Namespace ns = namespaceFor(sym);
         if (ns == null || ns.Name.Name == sym.Namespace)
             return sym;
         return Symbol.create(ns.Name.Name, sym.Name);
     }
     Object o = CurrentNamespace.GetMapping(sym);
     if (o == null)
         return Symbol.intern(CurrentNamespace.Name.Name, sym.Name);
     else if (o is Type)
         return Symbol.intern(null, Util.NameForType((Type)o));
     else if (o is Var)
     {
         Var v = (Var)o;
         return Symbol.create(v.Namespace.Name.Name, v.Symbol.Name);
     }
     return null;
 }

 public static object Resolve(Symbol symbol, bool allowPrivate)
 {
     return ResolveIn(CurrentNamespace, symbol, allowPrivate);
 }

 public void setTag(Symbol tag)
 {
     Tag = tag;
 }

 public static Var intern(Namespace ns, Symbol sym)
 {
     return ns.intern(sym);
 }

 public static Var find(Symbol nsQualifiedSym)
 {
     if (nsQualifiedSym.Namespace == null)
         throw new ArgumentException("Symbol must be namespace-qualified");
     Namespace ns = Namespace.find(Symbol.intern(nsQualifiedSym.Namespace));
     if (ns == null)
         throw new ArgumentException("No such namespace: " + nsQualifiedSym.Namespace);
     return ns.FindInternedVar(Symbol.intern(nsQualifiedSym.Name));
 }

 public static Namespace NamespaceFor(Symbol symbol)
 {
     return NamespaceFor(CurrentNamespace, symbol);
 }

        private static void CreateSuperCall(TypeBuilder proxyTB, Symbol p, MethodInfo mi)
        {
            Type[] paramTypes = CreateTypeArray(mi.GetParameters());

            MethodBuilder mb = proxyTB.DefineMethod(p.Name, MethodAttributes.Public, CallingConventions.HasThis, mi.ReturnType, paramTypes);
            ILGen gen = new ILGen(mb.GetILGenerator());
            gen.EmitLoadArg(0);                             // gen.Emit(OpCodes.Ldarg_0);
            for (int i = 0; i < paramTypes.Length; i++)
                gen.EmitLoadArg(i + 1);                     // gen.Emit(OpCodes.Ldarg, i + 1);
            gen.Emit(OpCodes.Call, mi);                     // not gen.EmitCall(mi); -- we need call versus callvirt
            gen.Emit(OpCodes.Ret);
        }

            static object ReadRecord(object form, Symbol recordName, object opts, object pendingForms)
            {
                bool readeval = RT.booleanCast(RT.ReadEvalVar.deref());
                if (!readeval)
                    throw new InvalidOperationException("Record construction syntax can only be used when *read-eval* == true ");

                Type recordType = RT.classForNameE(recordName.ToString());

                IPersistentVector recordEntries;
                IPersistentMap vals;

                object ret = null;
                ConstructorInfo[] allCtors = recordType.GetConstructors();

                if ((recordEntries = form as IPersistentVector) != null)
                {
                    // shortForm
                    bool ctorFound = false;
                    foreach (ConstructorInfo cinfo in allCtors)
                        if (cinfo.GetParameters().Length == recordEntries.count())
                            ctorFound = true;

                    if (!ctorFound)
                        throw new ArgumentException(String.Format("Unexpected number of constructor arguments to {0}: got {1}", recordType.ToString(), recordEntries.count()));

                    ret = Reflector.InvokeConstructor(recordType, RT.toArray(recordEntries));
                }
                else if ((vals = form as IPersistentMap) != null)
                {
                    for (ISeq s = RT.keys(vals); s != null; s = s.next())
                    {
                        if (!(s.first() is Keyword))
                            throw new ArgumentException(String.Format("Unreadable defrecord form: key must be of type clojure.lang.Keyword, got {0}", s.first().ToString()));
                    }

                    ret = Reflector.InvokeStaticMethod(recordType, "create", new Object[] { vals });
                }
                else
                {
                    throw new ArgumentException("Unreadable constructor form starting with \"#" + recordName + "\"");
                }

                return ret;
            }

        internal static Var LookupVar(Symbol sym, bool internNew)
        {
            Var var = null;

            // Note: ns-qualified vars in other namespaces must exist already
            if (sym.Namespace != null)
            {
                Namespace ns = Compiler.NamespaceFor(sym);
                if (ns == null)
                    return null;
                Symbol name = Symbol.create(sym.Name);
                if (internNew && ns == CurrentNamespace)
                    var = CurrentNamespace.intern(name);
                else
                    var = ns.FindInternedVar(name);
            }
            else if (sym.Equals(NS))
                var = RT.NS_VAR;
            else if (sym.Equals(IN_NS))
                var = RT.IN_NS_VAR;
            else
            {
                // is it mapped?
                Object o = CurrentNamespace.GetMapping(sym);
                if (o == null)
                {
                    // introduce a new var in the current ns
                    if (internNew)
                        var = CurrentNamespace.intern(Symbol.create(sym.Name));
                }
                else if (o is Var)
                    var = (Var)o;
                else
                    throw new Exception(string.Format("Expecting var, but {0} is mapped to {1}", sym, o));
            }
            if (var != null)
                RegisterVar(var);
            return var;
        }

 static object ReadTagged(object o, Symbol tag, object opts, object pendingForms)
 {
     ILookup dataReaders = (ILookup)RT.DataReadersVar.deref();
     IFn dataReader = (IFn)RT.get(dataReaders, tag);
     if (dataReader == null)
     {
         dataReaders = (ILookup)RT.DefaultDataReadersVar.deref();
         dataReader = (IFn)RT.get(dataReaders, tag);
         if (dataReader == null)
         {
             IFn default_reader = (IFn)RT.DefaultDataReaderFnVar.deref();
             if (default_reader != null)
                 return default_reader.invoke(tag, o);
             else
                 throw new ArgumentException("No reader function for tag " + tag.ToString());
         }
     }
     return dataReader.invoke(o);
 }

        internal static LocalBinding ReferenceLocal(Symbol symbol)
        {
            if (!LOCAL_ENV.IsBound)
                return null;

            LocalBinding b = (LocalBinding)RT.get(LOCAL_ENV.deref(), symbol);
            if (b != null)
            {
                FnMethod method = (FnMethod)METHODS.deref();
                CloseOver(b, method);
            }

            return b;
        }

        private static object ResolveIn(Namespace n, Symbol symbol, bool allowPrivate)
        {
            // note: ns-qualified vars must already exist
            if (symbol.Namespace != null)
            {
                Namespace ns = NamespaceFor(n, symbol);
                if (ns == null)
                    throw new Exception("No such namespace: " + symbol.Namespace);

                Var v = ns.FindInternedVar(Symbol.create(symbol.Name));
                if (v == null)
                    throw new Exception("No such var: " + symbol);
                else if (v.Namespace != CurrentNamespace && !v.IsPublic && !allowPrivate)
                    throw new InvalidOperationException(string.Format("var: {0} is not public", symbol));
                return v;
            }
            else if (symbol.Name.IndexOf('.') > 0 || symbol.Name[0] == '[')
                return RT.classForName(symbol.Name);
            else if (symbol.Equals(NS))
                return RT.NS_VAR;
            else if (symbol.Equals(IN_NS))
                return RT.IN_NS_VAR;
            else
            {
                object o = n.GetMapping(symbol);
                if (o == null)
                {
                    if (RT.booleanCast(RT.ALLOW_UNRESOLVED_VARS.deref()))
                        return symbol;
                    else
                        throw new Exception(string.Format("Unable to resolve symbol: {0} in this context", symbol));
                }
                return o;
            }
        }

        private static Expr AnalyzeSymbol(Symbol symbol)
        {
            Symbol tag = TagOf(symbol);

            if (symbol.Namespace == null)
            {
                LocalBinding b = ReferenceLocal(symbol);
                if (b != null)
                    return new LocalBindingExpr(b, tag);
            }
            else
            {
                if (namespaceFor(symbol) == null)
                {
                    Symbol nsSym = Symbol.create(symbol.Namespace);
                    Type t = MaybeType(nsSym, false);
                    if (t != null)
                    {
                        FieldInfo finfo;
                        PropertyInfo pinfo;

                        if ((finfo = Reflector.GetField(t, symbol.Name, true)) != null)
                            return new StaticFieldExpr((int)LINE.deref(), t, symbol.Name,finfo);
                        else if ((pinfo = Reflector.GetProperty(t, symbol.Name, true)) != null)
                            return new StaticPropertyExpr((int)LINE.deref(), t, symbol.Name,pinfo);
                    }
                    throw new Exception(string.Format("Unable to find static field: {0} in {1}", symbol.Name, t));
                }
            }

            object o = Compiler.Resolve(symbol);
            if (o is Var)
            {
                Var v = (Var)o;
                if (IsMacro(v) != null)
                    throw new Exception("Can't take the value of a macro: " + v);
                RegisterVar(v);
                return new VarExpr(v, tag);
            }
            else if (o is Type)
                return new ConstantExpr(o);
            else if (o is Symbol)
                return new UnresolvedVarExpr((Symbol)o);

            throw new Exception(string.Format("Unable to resolve symbol: {0} in this context", symbol));
        }