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
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
|
//
// System.Reflection.Emit/ConstructorBuilder.cs
//
// Author:
// Paolo Molaro (lupus@ximian.com)
//
// (C) 2001 Ximian, Inc. http://www.ximian.com
//
//
// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Globalization;
using System.Security;
using System.Security.Permissions;
using System.Runtime.InteropServices;
using System.Diagnostics.SymbolStore;
namespace System.Reflection.Emit {
#if NET_2_0
[ComVisible (true)]
[ComDefaultInterface (typeof (_ConstructorBuilder))]
#endif
[ClassInterface (ClassInterfaceType.None)]
public sealed class ConstructorBuilder : ConstructorInfo, _ConstructorBuilder {
private RuntimeMethodHandle mhandle;
private ILGenerator ilgen;
private Type[] parameters;
private MethodAttributes attrs;
private MethodImplAttributes iattrs;
private int table_idx;
private CallingConventions call_conv;
private TypeBuilder type;
private ParameterBuilder[] pinfo;
private CustomAttributeBuilder[] cattrs;
private bool init_locals = true;
private Type[][] paramModReq;
private Type[][] paramModOpt;
private RefEmitPermissionSet[] permissions;
internal ConstructorBuilder (TypeBuilder tb, MethodAttributes attributes, CallingConventions callingConvention, Type[] parameterTypes, Type[][] paramModReq, Type[][] paramModOpt) {
attrs = attributes | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName;
call_conv = callingConvention;
if (parameterTypes != null) {
for (int i = 0; i < parameterTypes.Length; ++i)
if (parameterTypes [i] == null)
throw new ArgumentException ("Elements of the parameterTypes array cannot be null", "parameterTypes");
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);
this.paramModReq = paramModReq;
this.paramModOpt = paramModOpt;
}
public bool InitLocals {
get {return init_locals;}
set {init_locals = value;}
}
internal TypeBuilder TypeBuilder {
get {return type;}
}
public override MethodImplAttributes GetMethodImplementationFlags() {
return iattrs;
}
public override ParameterInfo[] GetParameters() {
if (parameters == null)
return null;
ParameterInfo[] retval = new ParameterInfo [parameters.Length];
for (int i = 0; i < parameters.Length; i++) {
retval [i] = new ParameterInfo (pinfo == null ? null : pinfo [i+1], parameters [i], this, i + 1);
}
return retval;
}
internal override int GetParameterCount ()
{
if (parameters == null)
return 0;
return parameters.Length;
}
public override Object Invoke(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture) {
throw not_supported ();
}
public override object Invoke(BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture) {
throw not_supported ();
}
public override RuntimeMethodHandle MethodHandle {
get {
return mhandle;
}
}
public override MethodAttributes Attributes {
get {return attrs;}
}
public override Type ReflectedType { get {return type;}}
public override Type DeclaringType { get {return type;}}
public Type ReturnType { get {return null;}}
public override string Name {
get {return (attrs & MethodAttributes.Static) != 0 ? ".cctor" : ".ctor";}
}
public string Signature {
get {return "constructor signature";}
}
public void AddDeclarativeSecurity( SecurityAction action, PermissionSet pset) {
if (pset == null)
throw new ArgumentNullException ("pset");
if ((action == SecurityAction.RequestMinimum) ||
(action == SecurityAction.RequestOptional) ||
(action == SecurityAction.RequestRefuse))
throw new ArgumentException ("Request* values are not permitted", "action");
RejectIfCreated ();
if (permissions != null) {
/* Check duplicate actions */
foreach (RefEmitPermissionSet set in permissions)
if (set.action == action)
throw new InvalidOperationException ("Multiple permission sets specified with the same SecurityAction.");
RefEmitPermissionSet[] new_array = new RefEmitPermissionSet [permissions.Length + 1];
permissions.CopyTo (new_array, 0);
permissions = new_array;
}
else
permissions = new RefEmitPermissionSet [1];
permissions [permissions.Length - 1] = new RefEmitPermissionSet (action, pset.ToXml ().ToString ());
attrs |= MethodAttributes.HasSecurity;
}
public ParameterBuilder DefineParameter(int iSequence, ParameterAttributes attributes, string strParamName)
{
if ((iSequence < 1) || (iSequence > parameters.Length))
throw new ArgumentOutOfRangeException ("iSequence");
if (type.is_created)
throw not_after_created ();
ParameterBuilder pb = new ParameterBuilder (this, iSequence, attributes, strParamName);
if (pinfo == null)
pinfo = new ParameterBuilder [parameters.Length + 1];
pinfo [iSequence] = pb;
return pb;
}
public override bool IsDefined (Type attribute_type, bool inherit) {
throw not_supported ();
}
public override object [] GetCustomAttributes (bool inherit) {
/*
* On MS.NET, this always returns not_supported, but we can't do this
* since there would be no way to obtain custom attributes of
* dynamically created ctors.
*/
if (type.is_created)
return MonoCustomAttrs.GetCustomAttributes (this, inherit);
else
throw not_supported ();
}
public override object [] GetCustomAttributes (Type attributeType, bool inherit) {
if (type.is_created)
return MonoCustomAttrs.GetCustomAttributes (this, attributeType, inherit);
else
throw not_supported ();
}
public ILGenerator GetILGenerator () {
return GetILGenerator (64);
}
#if NET_2_0
public
#else
internal
#endif
ILGenerator GetILGenerator (int size) {
ilgen = new ILGenerator (type.Module, ((ModuleBuilder)type.Module).GetTokenGenerator (), size);
return ilgen;
}
public void SetCustomAttribute( CustomAttributeBuilder customBuilder) {
if (customBuilder == null)
throw new ArgumentNullException ("customBuilder");
string attrname = customBuilder.Ctor.ReflectedType.FullName;
if (attrname == "System.Runtime.CompilerServices.MethodImplAttribute") {
byte[] data = customBuilder.Data;
int impla; // the (stupid) ctor takes a short or an int ...
impla = (int)data [2];
impla |= ((int)data [3]) << 8;
SetImplementationFlags ((MethodImplAttributes)impla);
return;
}
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;
}
}
#if NET_2_0
[ComVisible (true)]
#endif
public void SetCustomAttribute( ConstructorInfo con, byte[] binaryAttribute) {
if (con == null)
throw new ArgumentNullException ("con");
if (binaryAttribute == null)
throw new ArgumentNullException ("binaryAttribute");
SetCustomAttribute (new CustomAttributeBuilder (con, binaryAttribute));
}
public void SetImplementationFlags( MethodImplAttributes attributes) {
if (type.is_created)
throw not_after_created ();
iattrs = attributes;
}
public Module GetModule() {
return type.Module;
}
public MethodToken GetToken() {
return new MethodToken (0x06000000 | table_idx);
}
[MonoTODO]
public void SetSymCustomAttribute( string name, byte[] data) {
if (type.is_created)
throw not_after_created ();
}
#if NET_2_0 || BOOTSTRAP_NET_2_0
public override bool IsGenericMethodDefinition {
get {
return false;
}
}
public override bool IsGenericMethod {
get {
return false;
}
}
public override Module Module {
get {
return base.Module;
}
}
#endif
public override string ToString() {
return "ConstructorBuilder ['" + type.Name + "']";
}
internal void fixup () {
if (((attrs & (MethodAttributes.Abstract | MethodAttributes.PinvokeImpl)) == 0) && ((iattrs & (MethodImplAttributes.Runtime | MethodImplAttributes.InternalCall)) == 0)) {
if ((ilgen == null) || (ILGenerator.Mono_GetCurrentOffset (ilgen) == 0))
throw new InvalidOperationException ("Method '" + Name + "' does not have a method body.");
}
if (ilgen != null)
ilgen.label_fixup ();
}
internal void GenerateDebugInfo (ISymbolWriter symbolWriter)
{
if (ilgen != null && ilgen.HasDebugInfo) {
SymbolToken token = new SymbolToken (GetToken().Token);
symbolWriter.OpenMethod (token);
symbolWriter.SetSymAttribute (token, "__name", System.Text.Encoding.UTF8.GetBytes (Name));
ilgen.GenerateDebugInfo (symbolWriter);
symbolWriter.CloseMethod ();
}
}
internal override int get_next_table_index (object obj, int table, bool inc) {
return type.get_next_table_index (obj, table, inc);
}
private void RejectIfCreated () {
if (type.is_created)
throw new InvalidOperationException ("Type definition of the method is complete.");
}
private Exception not_supported () {
return new NotSupportedException ("The invoked member is not supported in a dynamic module.");
}
private Exception not_after_created () {
return new InvalidOperationException ("Unable to change after type has been created.");
}
void _ConstructorBuilder.GetIDsOfNames ([In] ref Guid riid, IntPtr rgszNames, uint cNames, uint lcid, IntPtr rgDispId)
{
throw new NotImplementedException ();
}
void _ConstructorBuilder.GetTypeInfo (uint iTInfo, uint lcid, IntPtr ppTInfo)
{
throw new NotImplementedException ();
}
void _ConstructorBuilder.GetTypeInfoCount (out uint pcTInfo)
{
throw new NotImplementedException ();
}
void _ConstructorBuilder.Invoke (uint dispIdMember, [In] ref Guid riid, uint lcid, short wFlags, IntPtr pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, IntPtr puArgErr)
{
throw new NotImplementedException ();
}
}
}
|