1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
//
// System.Reflection.Emit/MethodBuilder.cs
//
// Author:
// Paolo Molaro (lupus@ximian.com)
//
// (C) 2001 Ximian, Inc. http://www.ximian.com
//
using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Globalization;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace System.Reflection.Emit {
public sealed class MethodBuilder : MethodInfo {
private RuntimeMethodHandle mhandle;
private Type rtype;
private Type[] parameters;
private MethodAttributes attrs;
private MethodImplAttributes iattrs;
private string name;
private int table_idx;
private byte[] code;
private ILGenerator ilgen;
private TypeBuilder type;
private ParameterBuilder[] pinfo;
private CustomAttributeBuilder[] cattrs;
private MethodInfo override_method;
private string pi_dll;
private string pi_entry;
private CharSet ncharset;
private CallingConvention native_cc;
private CallingConventions call_conv;
private bool init_locals = true;
internal MethodBuilder (TypeBuilder tb, string name, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes) {
this.name = name;
this.attrs = attributes;
this.call_conv = callingConvention;
this.rtype = returnType;
if (parameterTypes != null) {
this.parameters = new Type [parameterTypes.Length];
System.Array.Copy (parameterTypes, this.parameters, parameterTypes.Length);
}
type = tb;
table_idx = get_next_table_index (this, 0x06, true);
//Console.WriteLine ("index for "+name+" set to "+table_idx.ToString());
}
internal MethodBuilder (TypeBuilder tb, string name, MethodAttributes attributes,
CallingConventions callingConvention, Type returnType, Type[] parameterTypes,
String dllName, String entryName, CallingConvention nativeCConv, CharSet nativeCharset)
: this (tb, name, attributes, callingConvention, returnType, parameterTypes) {
pi_dll = dllName;
pi_entry = entryName;
native_cc = nativeCConv;
ncharset = nativeCharset;
}
public bool InitLocals {
get {return init_locals;}
set {init_locals = value;}
}
internal TypeBuilder TypeBuilder {
get {return type;}
}
public override Type ReturnType {get {return rtype;}}
public override Type ReflectedType {get {return type;}}
public override Type DeclaringType {get {return type;}}
public override string Name {get {return name;}}
public override RuntimeMethodHandle MethodHandle {get {return mhandle;}}
public override MethodAttributes Attributes {get {return attrs;}}
public override ICustomAttributeProvider ReturnTypeCustomAttributes {
get {return null;}
}
public MethodToken GetToken() {
return new MethodToken(0x06000000 | table_idx);
}
public override MethodInfo GetBaseDefinition() {
return null;
}
public override MethodImplAttributes GetMethodImplementationFlags() {
return iattrs;
}
public override ParameterInfo[] GetParameters() {
if ((parameters == null) || (pinfo == null))
return null;
ParameterInfo[] retval = new ParameterInfo [parameters.Length - 1];
for (int i = 1; i < parameters.Length; i++) {
if (pinfo [i] == null)
return null;
retval [i - 1] = new ParameterInfo (pinfo [i], parameters [i - 1], this);
}
return retval;
}
public void CreateMethodBody( byte[] il, int count) {
code = new byte [count];
System.Array.Copy(il, code, count);
}
public override Object Invoke(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture) {
return null;
}
public override bool IsDefined (Type attribute_type, bool inherit) {
return false;
}
public override object[] GetCustomAttributes( bool inherit) {
return null;
}
public override object[] GetCustomAttributes( Type attributeType, bool inherit) {
return null;
}
public ILGenerator GetILGenerator () {
return GetILGenerator (256);
}
public ILGenerator GetILGenerator (int size) {
ilgen = new ILGenerator (this, size);
return ilgen;
}
[MonoTODO]
public ParameterBuilder DefineParameter (int position, ParameterAttributes attributes, string strParamName)
{
ParameterBuilder pb = new ParameterBuilder (this, position, attributes, strParamName);
// check position
if (pinfo == null)
pinfo = new ParameterBuilder [parameters.Length + 1];
pinfo [position] = pb;
return pb;
}
internal void fixup () {
if (ilgen != null)
ilgen.label_fixup ();
}
public void SetCustomAttribute( CustomAttributeBuilder customBuilder) {
if (cattrs != null) {
CustomAttributeBuilder[] new_array = new CustomAttributeBuilder [cattrs.Length + 1];
cattrs.CopyTo (new_array, 0);
new_array [cattrs.Length] = customBuilder;
cattrs = new_array;
} else {
cattrs = new CustomAttributeBuilder [1];
cattrs [0] = customBuilder;
}
}
public void SetCustomAttribute( ConstructorInfo con, byte[] binaryAttribute) {
SetCustomAttribute (new CustomAttributeBuilder (con, binaryAttribute));
}
public void SetImplementationFlags( MethodImplAttributes attributes) {
iattrs = attributes;
}
internal override int get_next_table_index (object obj, int table, bool inc) {
return type.get_next_table_index (obj, table, inc);
}
internal void set_override (MethodInfo mdecl) {
override_method = mdecl;
}
}
}
|
