4 // Lluis Sanchez Gual (lluis@ximian.com)
6 // (C) 2004 Novell, Inc
9 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
11 // Permission is hereby granted, free of charge, to any person obtaining
12 // a copy of this software and associated documentation files (the
13 // "Software"), to deal in the Software without restriction, including
14 // without limitation the rights to use, copy, modify, merge, publish,
15 // distribute, sublicense, and/or sell copies of the Software, and to
16 // permit persons to whom the Software is furnished to do so, subject to
17 // the following conditions:
19 // The above copyright notice and this permission notice shall be
20 // included in all copies or substantial portions of the Software.
22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
34 using System
.Collections
;
35 using System
.Runtime
.Serialization
;
36 using System
.Reflection
;
37 using System
.Reflection
.Emit
;
38 using System
.Globalization
;
40 namespace System
.Runtime
.Serialization
.Formatters
.Binary
42 internal class CodeGenerator
46 static object monitor
= new object ();
48 static ModuleBuilder _module
;
50 static CodeGenerator ()
52 AppDomain myDomain
= System
.Threading
.Thread
.GetDomain();
53 AssemblyName myAsmName
= new AssemblyName();
54 myAsmName
.Name
= "__MetadataTypes";
56 AssemblyBuilder myAsmBuilder
= myDomain
.DefineInternalDynamicAssembly (myAsmName
, AssemblyBuilderAccess
.Run
);
57 _module
= myAsmBuilder
.DefineDynamicModule("__MetadataTypesModule", false);
60 static public Type
GenerateMetadataType (Type type
, StreamingContext context
) {
61 /* SRE is not thread safe */
63 return GenerateMetadataTypeInternal (type
, context
);
67 static public Type
GenerateMetadataTypeInternal (Type type
, StreamingContext context
)
69 string name
= type
.Name
+ "__TypeMetadata";
72 while (_module
.GetType (name
+ sufix
) != null)
73 sufix
= (++n
).ToString();
77 MemberInfo
[] members
= FormatterServices
.GetSerializableMembers (type
, context
);
79 TypeBuilder typeBuilder
= _module
.DefineType (name
, TypeAttributes
.Public
, typeof(ClrTypeMetadata
));
85 // *********************
86 // METHOD public constructor (Type t): base (t);
88 parameters
= Type
.EmptyTypes
;
90 ConstructorBuilder ctor
= typeBuilder
.DefineConstructor (MethodAttributes
.Public
, CallingConventions
.Standard
, parameters
);
91 ConstructorInfo baseCtor
= typeof(ClrTypeMetadata
).GetConstructor (new Type
[] { typeof(Type) }
);
92 gen
= ctor
.GetILGenerator();
94 gen
.Emit (OpCodes
.Ldarg_0
);
95 gen
.Emit (OpCodes
.Ldtoken
, type
);
96 gen
.EmitCall (OpCodes
.Call
, typeof(Type
).GetMethod("GetTypeFromHandle"), null);
97 gen
.Emit (OpCodes
.Call
, baseCtor
);
98 gen
.Emit (OpCodes
.Ret
);
100 // *********************
101 // METHOD public override void WriteAssemblies (ObjectWriter ow, BinaryWriter writer);
103 parameters
= new Type
[] { typeof(ObjectWriter), typeof(BinaryWriter) }
;
104 method
= typeBuilder
.DefineMethod ("WriteAssemblies", MethodAttributes
.Public
| MethodAttributes
.Virtual
, typeof(void), parameters
);
105 gen
= method
.GetILGenerator();
107 foreach (FieldInfo field
in members
)
109 Type memberType
= field
.FieldType
;
110 while (memberType
.IsArray
)
111 memberType
= memberType
.GetElementType();
113 if (memberType
.Assembly
!= ObjectWriter
.CorlibAssembly
)
115 // EMIT ow.WriteAssembly (writer, memberType.Assembly);
116 gen
.Emit (OpCodes
.Ldarg_1
);
117 gen
.Emit (OpCodes
.Ldarg_2
);
118 EmitLoadTypeAssembly (gen
, memberType
, field
.Name
);
119 gen
.EmitCall (OpCodes
.Callvirt
, typeof(ObjectWriter
).GetMethod("WriteAssembly"), null);
120 gen
.Emit (OpCodes
.Pop
);
123 gen
.Emit(OpCodes
.Ret
);
124 typeBuilder
.DefineMethodOverride (method
, typeof(TypeMetadata
).GetMethod ("WriteAssemblies"));
126 // *********************
127 // METHOD public override void WriteTypeData (ObjectWriter ow, BinaryWriter writer, bool writeTypes);
129 parameters
= new Type
[] { typeof(ObjectWriter), typeof(BinaryWriter), typeof(bool) }
;
130 method
= typeBuilder
.DefineMethod ("WriteTypeData", MethodAttributes
.Public
| MethodAttributes
.Virtual
, typeof(void), parameters
);
131 gen
= method
.GetILGenerator();
133 // EMIT writer.Write (members.Length);
134 gen
.Emit (OpCodes
.Ldarg_2
);
135 gen
.Emit (OpCodes
.Ldc_I4
, members
.Length
);
136 EmitWrite (gen
, typeof(int));
139 foreach (FieldInfo field
in members
)
141 // EMIT writer.Write (name);
142 gen
.Emit (OpCodes
.Ldarg_2
);
143 gen
.Emit (OpCodes
.Ldstr
, field
.Name
);
144 EmitWrite (gen
, typeof(string));
147 Label falseLabel
= gen
.DefineLabel ();
148 gen
.Emit (OpCodes
.Ldarg_3
);
149 gen
.Emit (OpCodes
.Brfalse
, falseLabel
);
152 foreach (FieldInfo field
in members
)
154 // EMIT writer.Write ((byte) ObjectWriter.GetTypeTag (type));
155 gen
.Emit (OpCodes
.Ldarg_2
);
156 gen
.Emit (OpCodes
.Ldc_I4_S
, (byte) ObjectWriter
.GetTypeTag (field
.FieldType
));
157 EmitWrite (gen
, typeof(byte));
160 // Type specs of fields
161 foreach (FieldInfo field
in members
)
163 // EMIT ow.WriteTypeSpec (writer, field.FieldType);
164 EmitWriteTypeSpec (gen
, field
.FieldType
, field
.Name
);
166 gen
.MarkLabel(falseLabel
);
168 gen
.Emit(OpCodes
.Ret
);
169 typeBuilder
.DefineMethodOverride (method
, typeof(TypeMetadata
).GetMethod ("WriteTypeData"));
171 // *********************
172 // METHOD public override void WriteObjectData (ObjectWriter ow, BinaryWriter writer, object data)
174 parameters
= new Type
[] { typeof(ObjectWriter), typeof(BinaryWriter), typeof(object) }
;
175 method
= typeBuilder
.DefineMethod ("WriteObjectData", MethodAttributes
.Public
| MethodAttributes
.Virtual
, typeof(void), parameters
);
176 gen
= method
.GetILGenerator();
178 LocalBuilder localBuilder
= gen
.DeclareLocal (type
);
179 OpCode lload
= OpCodes
.Ldloc
;
181 gen
.Emit (OpCodes
.Ldarg_3
);
182 if (type
.IsValueType
)
184 gen
.Emit (OpCodes
.Unbox
, type
);
185 LoadFromPtr (gen
, type
);
186 lload
= OpCodes
.Ldloca_S
;
189 gen
.Emit (OpCodes
.Castclass
, type
);
191 gen
.Emit (OpCodes
.Stloc
, localBuilder
);
193 foreach (FieldInfo field
in members
)
195 // EMIT ow.WriteValue (writer, ((FieldInfo)members[n]).FieldType, values[n]);
196 Type ftype
= field
.FieldType
;
197 if (BinaryCommon
.IsPrimitive (ftype
))
199 gen
.Emit (OpCodes
.Ldarg_2
);
200 gen
.Emit (lload
, localBuilder
);
201 if (ftype
== typeof(DateTime
) || ftype
== typeof(TimeSpan
) || ftype
== typeof(decimal))
202 gen
.Emit (OpCodes
.Ldflda
, field
);
204 gen
.Emit (OpCodes
.Ldfld
, field
);
205 EmitWritePrimitiveValue (gen
, ftype
);
209 gen
.Emit (OpCodes
.Ldarg_1
);
210 gen
.Emit (OpCodes
.Ldarg_2
);
211 gen
.Emit (OpCodes
.Ldtoken
, ftype
);
212 gen
.EmitCall (OpCodes
.Call
, typeof(Type
).GetMethod("GetTypeFromHandle"), null);
213 gen
.Emit (lload
, localBuilder
);
214 gen
.Emit (OpCodes
.Ldfld
, field
);
215 if (ftype
.IsValueType
)
216 gen
.Emit (OpCodes
.Box
, ftype
);
217 gen
.EmitCall (OpCodes
.Call
, typeof(ObjectWriter
).GetMethod("WriteValue"), null);
221 gen
.Emit(OpCodes
.Ret
);
222 typeBuilder
.DefineMethodOverride (method
, typeof(TypeMetadata
).GetMethod ("WriteObjectData"));
224 return typeBuilder
.CreateType();
227 public static void LoadFromPtr (ILGenerator ig
, Type t
)
229 if (t
== typeof(int))
230 ig
.Emit (OpCodes
.Ldind_I4
);
231 else if (t
== typeof(uint))
232 ig
.Emit (OpCodes
.Ldind_U4
);
233 else if (t
== typeof(short))
234 ig
.Emit (OpCodes
.Ldind_I2
);
235 else if (t
== typeof(ushort))
236 ig
.Emit (OpCodes
.Ldind_U2
);
237 else if (t
== typeof(char))
238 ig
.Emit (OpCodes
.Ldind_U2
);
239 else if (t
== typeof(byte))
240 ig
.Emit (OpCodes
.Ldind_U1
);
241 else if (t
== typeof(sbyte))
242 ig
.Emit (OpCodes
.Ldind_I1
);
243 else if (t
== typeof(ulong))
244 ig
.Emit (OpCodes
.Ldind_I8
);
245 else if (t
== typeof(long))
246 ig
.Emit (OpCodes
.Ldind_I8
);
247 else if (t
== typeof(float))
248 ig
.Emit (OpCodes
.Ldind_R4
);
249 else if (t
== typeof(double))
250 ig
.Emit (OpCodes
.Ldind_R8
);
251 else if (t
== typeof(bool))
252 ig
.Emit (OpCodes
.Ldind_I1
);
253 else if (t
== typeof(IntPtr
))
254 ig
.Emit (OpCodes
.Ldind_I
);
256 if (t
== typeof(Enum
))
257 ig
.Emit (OpCodes
.Ldind_Ref
);
259 LoadFromPtr (ig
, EnumToUnderlying (t
));
260 } else if (t
.IsValueType
)
261 ig
.Emit (OpCodes
.Ldobj
, t
);
263 ig
.Emit (OpCodes
.Ldind_Ref
);
266 static void EmitWriteTypeSpec (ILGenerator gen
, Type type
, string member
)
268 // WARNING Keep in sync with WriteTypeSpec
270 switch (ObjectWriter
.GetTypeTag (type
))
272 case TypeTag
.PrimitiveType
:
273 // EMIT writer.Write (BinaryCommon.GetTypeCode (type));
274 gen
.Emit (OpCodes
.Ldarg_2
);
275 gen
.Emit (OpCodes
.Ldc_I4_S
, (byte) BinaryCommon
.GetTypeCode (type
));
276 EmitWrite (gen
, typeof(byte));
279 case TypeTag
.RuntimeType
:
280 // EMIT writer.Write (type.FullName);
281 gen
.Emit (OpCodes
.Ldarg_2
);
282 gen
.Emit (OpCodes
.Ldstr
, type
.FullName
);
283 EmitWrite (gen
, typeof(string));
286 case TypeTag
.GenericType
:
287 // EMIT writer.Write (type.FullName);
288 gen
.Emit (OpCodes
.Ldarg_2
);
289 gen
.Emit (OpCodes
.Ldstr
, type
.FullName
);
290 EmitWrite (gen
, typeof(string));
292 // EMIT writer.Write ((int)ow.GetAssemblyId (type.Assembly));
293 gen
.Emit (OpCodes
.Ldarg_2
);
294 gen
.Emit (OpCodes
.Ldarg_1
);
295 EmitLoadTypeAssembly (gen
, type
, member
);
296 gen
.EmitCall (OpCodes
.Callvirt
, typeof(ObjectWriter
).GetMethod("GetAssemblyId"), null);
297 gen
.Emit (OpCodes
.Conv_I4
);
298 EmitWrite (gen
, typeof(int));
301 case TypeTag
.ArrayOfPrimitiveType
:
302 // EMIT writer.Write (BinaryCommon.GetTypeCode (type.GetElementType()));
303 gen
.Emit (OpCodes
.Ldarg_2
);
304 gen
.Emit (OpCodes
.Ldc_I4_S
, (byte) BinaryCommon
.GetTypeCode (type
.GetElementType()));
305 EmitWrite (gen
, typeof(byte));
309 // Type spec not needed
314 static void EmitLoadTypeAssembly (ILGenerator gen
, Type type
, string member
)
316 gen
.Emit (OpCodes
.Ldtoken
, type
);
317 gen
.EmitCall (OpCodes
.Call
, typeof(Type
).GetMethod("GetTypeFromHandle"), null);
318 gen
.EmitCall (OpCodes
.Callvirt
, typeof(Type
).GetProperty("Assembly").GetGetMethod(), null);
321 static void EmitWrite (ILGenerator gen
, Type type
)
323 gen
.EmitCall (OpCodes
.Callvirt
, typeof(BinaryWriter
).GetMethod("Write", new Type
[] { type }
), null);
326 public static void EmitWritePrimitiveValue (ILGenerator gen
, Type type
)
328 switch (Type
.GetTypeCode (type
))
330 case TypeCode
.Boolean
:
333 case TypeCode
.Double
:
338 case TypeCode
.Single
:
339 case TypeCode
.UInt16
:
340 case TypeCode
.UInt32
:
341 case TypeCode
.UInt64
:
342 case TypeCode
.String
:
343 EmitWrite (gen
, type
);
346 case TypeCode
.Decimal
:
347 // writer.Write (val.ToString (CultureInfo.InvariantCulture));
348 gen
.EmitCall (OpCodes
.Call
, typeof(CultureInfo
).GetProperty("InvariantCulture").GetGetMethod(), null);
349 gen
.EmitCall (OpCodes
.Call
, typeof(Decimal
).GetMethod("ToString", new Type
[] {typeof(IFormatProvider)}
), null);
350 EmitWrite (gen
, typeof(string));
353 case TypeCode
.DateTime
:
354 gen
.EmitCall (OpCodes
.Call
, typeof(DateTime
).GetMethod("ToBinary", BindingFlags
.Public
| BindingFlags
.NonPublic
| BindingFlags
.Instance
), null);
355 EmitWrite (gen
, typeof(long));
359 if (type
== typeof (TimeSpan
)) {
360 gen
.EmitCall (OpCodes
.Call
, typeof(TimeSpan
).GetProperty("Ticks").GetGetMethod(), null);
361 EmitWrite (gen
, typeof(long));
364 throw new NotSupportedException ("Unsupported primitive type: " + type
.FullName
);
370 // This is needed, because enumerations from assemblies
371 // do not report their underlyingtype, but they report
374 public static Type
EnumToUnderlying (Type t
)
376 TypeCode tc
= Type
.GetTypeCode (t
);
379 case TypeCode
.Boolean
:
380 return typeof (bool);
382 return typeof (byte);
384 return typeof (sbyte);
386 return typeof (char);
388 return typeof (short);
389 case TypeCode
.UInt16
:
390 return typeof (ushort);
393 case TypeCode
.UInt32
:
394 return typeof (uint);
396 return typeof (long);
397 case TypeCode
.UInt64
:
398 return typeof (ulong);
400 throw new Exception ("Unhandled typecode in enum " + tc
+ " from " + t
.AssemblyQualifiedName
);