C# Ast.GenContext类代码示例

        public static Type GenerateInterface(string iName, ISeq extends, ISeq methods)
        {
            GenContext context = new GenContext(iName, CompilerMode.File);

            //            GenContext context = (GenContext)Compiler.COMPILER_CONTEXT.deref();
            //            if (context == null)
            //            {
            //#if DEBUG
            //                context = new GenContext(iName, CompilerMode.File);
            //#else
            //                throw new InvalidOperationException("No compiler context on the stack.");
            //#endif
            //            }

            Type[] interfaceTypes = GenClass.CreateTypeArray(extends == null ? null : extends.seq());

            TypeBuilder proxyTB = context.ModuleBldr.DefineType(
                iName,
                TypeAttributes.Interface | TypeAttributes.Public | TypeAttributes.Abstract,
                null,
                interfaceTypes);

            DefineMethods(proxyTB, methods);

            Type t = proxyTB.CreateType();
            context.AssyBldr.Save(iName  + ".dll");
            return t;
        }

 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 override Expression GenDlr(GenContext context)
 {
     if (_method != null)
         return Compiler.MaybeBox(GenDlrForMethod(context));
     else
         return GenDlrViaReflection(context);
 }

        public Expression GenCode(RHC rhc, ObjExpr objx, GenContext context)
        {
            int n = _bindingInits.count();
            List<ParameterExpression> parms = new List<ParameterExpression>(n);
            List<Expression> forms = new List<Expression>(n);

            /// First, set up the environment.
            for (int i = 0; i < n; i++)
            {
                BindingInit bi = (BindingInit)_bindingInits.nth(i);
                ParameterExpression parmExpr = Expression.Parameter(typeof(IFn), bi.Binding.Name);
                bi.Binding.ParamExpression = parmExpr;
                parms.Add(parmExpr);
            }

            // Then initialize
            for (int i = 0; i < n; i++)
            {
                BindingInit bi = (BindingInit)_bindingInits.nth(i);
                ParameterExpression parmExpr = (ParameterExpression)bi.Binding.ParamExpression;
                forms.Add(Expression.Assign(parmExpr, bi.Init.GenCode(RHC.Expression,objx,context)));
            }

            // The work
            forms.Add(_body.GenCode(rhc,objx,context));
            return Expression.Block(parms,forms);
        }

        public Expression GenCode(RHC rhc, ObjExpr objx, GenContext context)
        {
            List<Expression> exprs = new List<Expression>();

            ParameterExpression parm = Expression.Parameter(typeof(Var), "v");

            Expression varExpr = objx.GenVar(context,_var);

            exprs.Add(Expression.Assign(parm, varExpr));

            // The Java code does the following in the opposite order (as modified in commit #430dd4f, Jan 19, 2010)
            // However, the call to bindRoot sets :macro to False.  I'm not sure how it works now in the JVM version.

            if (_initProvided )
                // Java doesn't Box here, but we have to deal with unboxed bool values
                exprs.Add(Expression.Call(parm, Compiler.Method_Var_bindRoot, Compiler.MaybeBox(_init.GenCode(RHC.Expression,objx,context))));

            if (_meta != null)
            {
                if (_initProvided || IncludesExplicitMetadata((MapExpr)_meta))
                {
                    // Java casts to IPersistentMap on the _meta, but Expression.Call can handle that for us.
                    exprs.Add(Expression.Call(parm, Compiler.Method_Var_setMeta, _meta.GenCode(RHC.Expression,objx,context)));
                }
            }

            exprs.Add(parm);

            return Expression.Block(new ParameterExpression[] { parm }, exprs);
        }

        private Expression GenDlrForMethod(GenContext context)
        {
            Expression target = _target.GenDlr(context);
            Expression[] args = GenTypedArgs(context, _method.GetParameters(), _args);

            return AstUtils.SimpleCallHelper(target,_method, args); ;
        }

        internal static Type Create(GenContext context, Type baseClass)
        {
            //ModuleBuilder mb = context.ModuleBldr;
            string name = baseClass.Name + "_impl";
            //TypeBuilder baseTB = context.ModuleBldr.DefineType(name, TypeAttributes.Class | TypeAttributes.Public, baseClass);
            TypeBuilder baseTB = context.AssemblyGen.DefinePublicType(name, baseClass, true);

            ObjExpr.MarkAsSerializable(baseTB);

            baseTB.DefineDefaultConstructor(MethodAttributes.Public);

            FieldBuilder metaField = baseTB.DefineField("_meta", typeof(IPersistentMap), FieldAttributes.Public);

            MethodBuilder metaMB = baseTB.DefineMethod("meta", MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.ReuseSlot, typeof(IPersistentMap), Type.EmptyTypes);
            ILGen gen = new ILGen(metaMB.GetILGenerator());
            gen.EmitLoadArg(0);
            gen.EmitFieldGet(metaField);
            gen.Emit(OpCodes.Ret);

            MethodBuilder withMB = baseTB.DefineMethod("withMeta", MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.ReuseSlot, typeof(IObj), new Type[] { typeof(IPersistentMap)});
            gen = new ILGen(withMB.GetILGenerator());
            gen.EmitLoadArg(0);
            gen.EmitCall(Compiler.Method_Object_MemberwiseClone);
            gen.Emit(OpCodes.Castclass, baseTB);
            gen.Emit(OpCodes.Dup);
            gen.EmitLoadArg(1);
            gen.EmitFieldSet(metaField);
            gen.Emit(OpCodes.Ret);

            for (int i = 0; i < 20; i++ )
                DefineDelegateFieldAndOverride(baseTB, i);

            return baseTB.CreateType();
        }

 public override Expression GenDlrUnboxed(GenContext context)
 {
     if (_method != null)
         return GenDlrForMethod(context);
     else
         throw new InvalidOperationException("Unboxed emit of unknown member.");
 }

        public override Expression GenCode(RHC rhc, ObjExpr objx, GenContext context)
        {
            Expression exc = _excExpr.GenCode(RHC.Expression, objx, context);
            Expression exc2 = Expression.Convert(exc, typeof(Exception));

            return Expression.Throw(exc2,typeof(object));
        }

 public override Expression GenDlr(GenContext context)
 {
     Expression getTypeExpr = Expression.Call(null, Compiler.Method_RT_classForName, Expression.Constant(_c));
     //Expression getNsExpr = Expression.Call(null, Compiler.Method_Compiler_CurrentNamespace);
     Expression getNsExpr = Expression.Property(null, Compiler.Method_Compiler_CurrentNamespace);
     return Expression.Call(getNsExpr, Compiler.Method_Namespace_importClass1, getTypeExpr);
 }

        public override Expression GenDlr(GenContext context)
        {
            Expression basicBody = _tryExpr.GenDlr(context);
            // Wrap the basic body, a Comma, in a return to a label
            LabelTarget target = Expression.Label(basicBody.Type, "ret_label");
            //Expression tryBody = Expression.Return(target, basicBody);
            Expression tryBody = basicBody;

            CatchBlock[] catches = new CatchBlock[_catchExprs.count()];
            for ( int i=0; i<_catchExprs.count(); i++ )
            {
                CatchClause clause = (CatchClause) _catchExprs.nth(i);
                ParameterExpression parmExpr = Expression.Parameter(clause.Type, clause.Lb.Name);
                clause.Lb.ParamExpression = parmExpr;
                catches[i] = Expression.Catch(parmExpr,clause.Handler.GenDlr(context));
            }

            TryExpression tryStmt = _finallyExpr == null
                ? Expression.TryCatch(tryBody, catches)
                : Expression.TryCatchFinally(tryBody, _finallyExpr.GenDlr(context), catches);

            Expression defaultValue = Expression.Default(basicBody.Type);
            Expression whole = Expression.Block(tryStmt, Expression.Label(target, defaultValue));
            return whole;
        }

        public override Expression GenDlr(GenContext context)
        {
            Expression exc = _excExpr.GenDlr(context);
            Expression exc2 = Expression.Convert(exc, typeof(Exception));

            return Expression.Throw(exc2);
        }

 internal static Expression GenTypedArg(GenContext context, Type type, Expr arg)
 {
     if (Compiler.MaybePrimitiveType(arg) == type)
         return ((MaybePrimitiveExpr)arg).GenDlrUnboxed(context);
     else
         // Java has emitUnboxArg -- should we do something similar?
         return arg.GenDlr(context);
 }

 internal static Expression GenTypedArg(GenContext context, Type type, Expr arg)
 {
     if (Compiler.MaybePrimitiveType(arg) == type)
         return ((MaybePrimitiveExpr)arg).GenDlrUnboxed(context);
     else
     {
         Expression argExpr = arg.GenDlr(context);
         return GenMaybeUnboxedArg(type, argExpr);
     }
 }

        public override Expression GenCode(RHC rhc, ObjExpr objx, GenContext context)
        {
            Expression call;

            if (_method != null)
                call = GenDlrForMethod(objx, context);
            else
                call = GenerateComplexCall(objx, context);
            call = Compiler.MaybeAddDebugInfo(call, _spanMap, context.IsDebuggable);
            return call;
        }