protected override MethodEmitter BuildProxiedMethodBody(MethodEmitter emitter, ClassEmitter @class,
                                                                ProxyGenerationOptions options, INamingScope namingScope)
        {
            if (emitter.ReturnType == typeof(int))
            {
                MethodBuilder   methodBuilder  = emitter.MethodBuilder;
                ILGenerator     ilGenerator    = methodBuilder.GetILGenerator();
                ParameterInfo[] parameterInfos = MethodToOverride.GetParameters();

                var v      = new ILTemplateEmitter(ilGenerator, templateMethod, MethodToOverride, methodBuilder);
                var reader = new ILReader(templateMethod);
                reader.Accept(v);

                return(emitter);
            }

            InitOutParameters(emitter, MethodToOverride.GetParameters());

            if (emitter.ReturnType == typeof(void))
            {
                emitter.CodeBuilder.AddStatement(new ReturnStatement());
            }
            else
            {
                emitter.CodeBuilder.AddStatement(new ReturnStatement(new DefaultValueExpression(emitter.ReturnType)));
            }

            return(emitter);
        }
Example #2
0
        protected void ToPrintableByteCodeIntern(Type type, StringBuilder sb)
        {
            if (type.BaseType != null && typeof(IEnhancedType).IsAssignableFrom(type.BaseType))
            {
                // write parent classes first
                ToPrintableByteCodeIntern(type.BaseType, sb);
                sb.Append('\n');
            }
            sb.Append(type.ToString());

            StringWriter         sw      = new StringWriter(sb);
            ILInstructionVisitor visitor = new ReadableILStringVisitor(new ReadableILStringToTextWriter(sw));

            if (type is TypeBuilder)
            {
                MethodInstance[] methods = BytecodeBehaviorState.State.GetAlreadyImplementedMethodsOnNewType();

                foreach (MethodInstance method in methods)
                {
                    sb.Append('\n');
                    PrintAnnotations(method.Method, sb);
                    sb.Append(method.ToString()).Append('\n');

                    ILReader reader = new ILReader(method.Method);

                    reader.Accept(visitor);
                }
                return;
            }
            {
                ConstructorInfo[] constructors = type.GetConstructors(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
                MethodInfo[]      methods      = type.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
                FieldInfo[]       fields       = type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

                foreach (FieldInfo field in fields)
                {
                    sb.Append('\n');
                    PrintAnnotations(field, sb);
                    sb.Append(field.ToString()).Append('\n');
                }

                foreach (ConstructorInfo constructor in constructors)
                {
                    sb.Append('\n');
                    PrintAnnotations(constructor, sb);
                    sb.Append(constructor.ToString()).Append('\n');

                    ILReader reader = new ILReader(constructor);

                    reader.Accept(visitor);
                }

                foreach (MethodInfo method in methods)
                {
                    sb.Append('\n');
                    PrintAnnotations(method, sb);
                    sb.Append(method.ToString()).Append('\n');

                    ILReader reader = new ILReader(method);

                    reader.Accept(visitor);
                }
            }
        }