protected override void EmitPackMembers(SerializerEmitter emitter, TracingILGenerator packerIL, SerializingMember[] entries) { var localHolder = new LocalVariableHolder(packerIL); packerIL.EmitAnyLdarg(1); packerIL.EmitAnyLdc_I4(entries.Length); packerIL.EmitAnyCall(Metadata._Packer.PackArrayHeader); packerIL.EmitPop(); foreach (var member in entries) { if (member.Member == null) { // missing member, always nil packerIL.EmitAnyLdarg(1); packerIL.EmitAnyCall(Metadata._Packer.PackNull); packerIL.EmitPop(); } else { Emittion.EmitSerializeValue( emitter, packerIL, 1, member.Member.GetMemberValueType(), member.Member.Name, member.Contract.NilImplication, il => { if (typeof(TObject).IsValueType) { il.EmitAnyLdarga(2); } else { il.EmitAnyLdarg(2); } Emittion.EmitLoadValue(il, member.Member); }, localHolder ); } } packerIL.EmitRet(); }
protected sealed override void EmitPackMembers(SerializerEmitter emitter, TracingILGenerator packerIL, SerializingMember[] entries) { var localHolder = new LocalVariableHolder(packerIL); packerIL.EmitAnyLdarg(1); packerIL.EmitAnyLdc_I4(entries.Length); packerIL.EmitAnyCall(Metadata._Packer.PackMapHeader); packerIL.EmitPop(); foreach (var entry in entries) { if (entry.Member == null) { // skip undefined member. continue; } packerIL.EmitAnyLdarg(1); packerIL.EmitLdstr(entry.Contract.Name); packerIL.EmitAnyCall(Metadata._Packer.PackString); packerIL.EmitPop(); Emittion.EmitSerializeValue( emitter, packerIL, 1, entry.Member.GetMemberValueType(), entry.Contract.Name, entry.Contract.NilImplication, il0 => { if (typeof(TObject).IsValueType) { il0.EmitAnyLdarga(2); } else { il0.EmitAnyLdarg(2); } Emittion.EmitLoadValue(il0, entry.Member); }, localHolder ); } packerIL.EmitRet(); }
protected override void EmitPackMembers(SerializerEmitter emitter, TracingILGenerator packerIL, SerializingMember[] entries) { LocalVariableHolder localHolder = new LocalVariableHolder(packerIL); packerIL.EmitAnyLdarg(1); packerIL.EmitAnyLdc_I4(entries.Length); packerIL.EmitAnyCall(_Packer.PackArrayHeader); packerIL.EmitPop(); SerializingMember[] memberArray = entries; for (int i = 0; i < memberArray.Length; i++) { Action <TracingILGenerator> loadValueEmitter = null; SerializingMember member = memberArray[i]; if (member.Member == null) { packerIL.EmitAnyLdarg(1); packerIL.EmitAnyCall(_Packer.PackNull); packerIL.EmitPop(); } else { if (loadValueEmitter == null) { loadValueEmitter = delegate(TracingILGenerator il) { if (typeof(TObject).IsValueType) { il.EmitAnyLdarga(2); } else { il.EmitAnyLdarg(2); } Emittion.EmitLoadValue(il, member.Member); }; } Emittion.EmitSerializeValue(emitter, packerIL, 1, member.Member.GetMemberValueType(), member.Member.Name, member.Contract.NilImplication, loadValueEmitter, localHolder); } } packerIL.EmitRet(); }
private static void CreateTuplePack(SerializerEmitter emiter, Type tupleType, IList <Type> itemTypes, Action <TracingILGenerator, LocalBuilder> loadTupleEmitter) { var il = emiter.GetPackToMethodILGenerator(); var localHolder = new LocalVariableHolder(il); try { /* * packer.PackArrayHeader( cardinarity ); * _serializer0.PackTo( packer, tuple.Item1 ); * : * _serializer6.PackTo( packer, tuple.item7 ); * _serializer7.PackTo( packer, tuple.Rest.Item1 ); */ var tuple = il.DeclareLocal(tupleType, "tuple"); loadTupleEmitter(il, tuple); il.EmitAnyLdarg(1); il.EmitAnyLdc_I4(itemTypes.Count); il.EmitAnyCall(Metadata._Packer.PackArrayHeader); il.EmitPop(); var tupleTypeList = TupleItems.CreateTupleTypeList(itemTypes); int depth = -1; for (int i = 0; i < itemTypes.Count; i++) { if (i % 7 == 0) { depth++; } Emittion.EmitSerializeValue( emiter, il, 1, itemTypes[i], null, NilImplication.MemberDefault, il0 => { il0.EmitAnyLdloc(tuple); for (int j = 0; j < depth; j++) { // .TRest.TRest ... var rest = tupleTypeList[j].GetProperty("Rest"); il0.EmitGetProperty(rest); } var itemn = tupleTypeList[depth].GetProperty("Item" + ((i % 7) + 1)); #if DEBUG Contract.Assert(itemn != null, tupleTypeList[depth].GetFullName() + "::Item" + ((i % 7) + 1) + " [ " + depth + " ] @ " + i); #endif il0.EmitGetProperty(itemn); }, localHolder ); } il.EmitRet(); } finally { il.FlushTrace(); } }
private static void CreatePackArrayProceduresCore(Type targetType, SerializerEmitter emitter, CollectionTraits traits) { var il = emitter.GetPackToMethodILGenerator(); var localHolder = new LocalVariableHolder(il); try { // Array if (targetType.IsArray) { /* * // array * packer.PackArrayHeader( length ); * for( int i = 0; i < length; i++ ) * { * this._serializer.PackTo( packer, collection[ i ] ); * } */ var length = localHolder.PackingCollectionCount; il.EmitAnyLdarg(2); il.EmitLdlen(); il.EmitAnyStloc(length); il.EmitAnyLdarg(1); il.EmitAnyLdloc(length); il.EmitAnyCall(Metadata._Packer.PackArrayHeader); il.EmitPop(); Emittion.EmitFor( il, length, (il0, i) => Emittion.EmitSerializeValue( emitter, il0, 1, traits.ElementType, null, NilImplication.MemberDefault, il1 => { il1.EmitAnyLdarg(2); il1.EmitAnyLdloc(i); il1.EmitLdelem(traits.ElementType); }, localHolder ) ); } else if (traits.CountProperty == null) { /* * array = collection.ToArray(); * packer.PackArrayHeader( length ); * for( int i = 0; i < length; i++ ) * { * this._serializer.PackTo( packer, array[ i ] ); * } */ var array = localHolder.GetSerializingCollection(traits.ElementType.MakeArrayType()); EmitLoadTarget(targetType, il, 2); il.EmitAnyCall(Metadata._Enumerable.ToArray1Method.MakeGenericMethod(traits.ElementType)); il.EmitAnyStloc(array); var length = localHolder.PackingCollectionCount; il.EmitAnyLdloc(array); il.EmitLdlen(); il.EmitAnyStloc(length); il.EmitAnyLdarg(1); il.EmitAnyLdloc(length); il.EmitAnyCall(Metadata._Packer.PackArrayHeader); il.EmitPop(); Emittion.EmitFor( il, length, (il0, i) => Emittion.EmitSerializeValue( emitter, il0, 1, traits.ElementType, null, NilImplication.MemberDefault, il1 => { il1.EmitAnyLdloc(array); il1.EmitAnyLdloc(i); il1.EmitLdelem(traits.ElementType); }, localHolder ) ); } else { /* * // Enumerable * packer.PackArrayHeader( collection.Count ); * foreach( var item in list ) * { * this._serializer.PackTo( packer, array[ i ] ); * } */ var collection = localHolder.GetSerializingCollection(targetType); // This instruction always ldarg, not to be ldarga il.EmitAnyLdarg(2); il.EmitAnyStloc(collection); var count = localHolder.PackingCollectionCount; EmitLoadTarget(targetType, il, 2); il.EmitGetProperty(traits.CountProperty); il.EmitAnyStloc(count); il.EmitAnyLdarg(1); il.EmitAnyLdloc(count); il.EmitAnyCall(Metadata._Packer.PackArrayHeader); il.EmitPop(); Emittion.EmitForEach( il, traits, collection, (il0, getCurrentEmitter) => Emittion.EmitSerializeValue( emitter, il0, 1, traits.ElementType, null, NilImplication.MemberDefault, _ => getCurrentEmitter(), localHolder ) ); } il.EmitRet(); } finally { il.FlushTrace(); } }
private static void CreateMapPack(Type targetType, SerializerEmitter emiter, CollectionTraits traits) { var il = emiter.GetPackToMethodILGenerator(); var localHolder = new LocalVariableHolder(il); try { /* * int count = ((ICollection<KeyValuePair<string, DateTime>>)dictionary).Count; * packer.PackMapHeader(count); * foreach (KeyValuePair<string, DateTime> current in dictionary) * { * this._serializer0.PackTo(packer, current.Key); * this._serializer1.PackTo(packer, current.Value); * } */ var collection = localHolder.GetSerializingCollection(targetType); var item = localHolder.GetSerializingCollectionItem(traits.ElementType); var keyProperty = traits.ElementType.GetProperty("Key"); var valueProperty = traits.ElementType.GetProperty("Value"); // This instruction is always ldarg, not to be ldarga. il.EmitAnyLdarg(2); il.EmitAnyStloc(collection); var count = localHolder.PackingCollectionCount; EmitLoadTarget(targetType, il, collection); il.EmitGetProperty(traits.CountProperty); il.EmitAnyStloc(count); il.EmitAnyLdarg(1); il.EmitAnyLdloc(count); il.EmitAnyCall(Metadata._Packer.PackMapHeader); il.EmitPop(); Emittion.EmitForEach( il, traits, collection, (il0, getCurrentEmitter) => { if (traits.ElementType.IsGenericType) { Contract.Assert(traits.ElementType.GetGenericTypeDefinition() == typeof(KeyValuePair <,>)); getCurrentEmitter(); il0.EmitAnyStloc(item); Emittion.EmitSerializeValue( emiter, il0, 1, traits.ElementType.GetGenericArguments()[0], null, NilImplication.MemberDefault, il1 => { il1.EmitAnyLdloca(item); il1.EmitGetProperty(keyProperty); }, localHolder ); Emittion.EmitSerializeValue( emiter, il0, 1, traits.ElementType.GetGenericArguments()[1], null, NilImplication.MemberDefault, il1 => { il1.EmitAnyLdloca(item); il1.EmitGetProperty(valueProperty); }, localHolder ); } else { Contract.Assert(traits.ElementType == typeof(DictionaryEntry)); getCurrentEmitter(); il0.EmitAnyStloc(item); Emittion.EmitSerializeValue( emiter, il0, 1, typeof(MessagePackObject), null, NilImplication.MemberDefault, il1 => { il0.EmitAnyLdloca(item); il0.EmitGetProperty(Metadata._DictionaryEntry.Key); il0.EmitUnbox_Any(typeof(MessagePackObject)); }, localHolder ); Emittion.EmitSerializeValue( emiter, il0, 1, typeof(MessagePackObject), null, NilImplication.MemberDefault, il1 => { il0.EmitAnyLdloca(item); il0.EmitGetProperty(Metadata._DictionaryEntry.Value); il0.EmitUnbox_Any(typeof(MessagePackObject)); }, localHolder ); } } ); il.EmitRet(); } finally { il.FlushTrace(); } }
private static void CreateMapPack(Type targetType, SerializerEmitter emiter, CollectionTraits traits) { TracingILGenerator packToMethodILGenerator = emiter.GetPackToMethodILGenerator(); LocalVariableHolder localHolder = new LocalVariableHolder(packToMethodILGenerator); try { < > c__DisplayClass20 class3; LocalBuilder serializingCollection = localHolder.GetSerializingCollection(targetType); LocalBuilder item = localHolder.GetSerializingCollectionItem(traits.ElementType); PropertyInfo keyProperty = traits.ElementType.GetProperty("Key"); PropertyInfo valueProperty = traits.ElementType.GetProperty("Value"); packToMethodILGenerator.EmitAnyLdarg(2); packToMethodILGenerator.EmitAnyStloc(serializingCollection); LocalBuilder packingCollectionCount = localHolder.PackingCollectionCount; EmitLoadTarget(targetType, packToMethodILGenerator, serializingCollection); packToMethodILGenerator.EmitGetProperty(traits.CountProperty); packToMethodILGenerator.EmitAnyStloc(packingCollectionCount); packToMethodILGenerator.EmitAnyLdarg(1); packToMethodILGenerator.EmitAnyLdloc(packingCollectionCount); packToMethodILGenerator.EmitAnyCall(_Packer.PackMapHeader); packToMethodILGenerator.EmitPop(); Emittion.EmitForEach(packToMethodILGenerator, traits, serializingCollection, delegate(TracingILGenerator il0, Action getCurrentEmitter) { Action <TracingILGenerator> loadValueEmitter = null; Action <TracingILGenerator> action2 = null; Action <TracingILGenerator> action3 = null; Action <TracingILGenerator> action4 = null; < > c__DisplayClass20 class1 = class3; if (traits.ElementType.IsGenericType) { Contract.Assert(traits.ElementType.GetGenericTypeDefinition() == typeof(KeyValuePair <,>)); getCurrentEmitter(); il0.EmitAnyStloc(item); if (loadValueEmitter == null) { loadValueEmitter = delegate(TracingILGenerator il1) { il1.EmitAnyLdloca(item); il1.EmitGetProperty(keyProperty); }; } Emittion.EmitSerializeValue(emiter, il0, 1, traits.ElementType.GetGenericArguments()[0], null, NilImplication.MemberDefault, loadValueEmitter, localHolder); if (action2 == null) { action2 = delegate(TracingILGenerator il1) { il1.EmitAnyLdloca(item); il1.EmitGetProperty(valueProperty); }; } Emittion.EmitSerializeValue(emiter, il0, 1, traits.ElementType.GetGenericArguments()[1], null, NilImplication.MemberDefault, action2, localHolder); } else { Contract.Assert(traits.ElementType == typeof(DictionaryEntry)); getCurrentEmitter(); il0.EmitAnyStloc(item); if (action3 == null) { action3 = delegate(TracingILGenerator il1) { il0.EmitAnyLdloca(item); il0.EmitGetProperty(_DictionaryEntry.Key); il0.EmitUnbox_Any(typeof(MessagePackObject)); }; } Emittion.EmitSerializeValue(emiter, il0, 1, typeof(MessagePackObject), null, NilImplication.MemberDefault, action3, localHolder); if (action4 == null) { action4 = delegate(TracingILGenerator il1) { il0.EmitAnyLdloca(item); il0.EmitGetProperty(_DictionaryEntry.Value); il0.EmitUnbox_Any(typeof(MessagePackObject)); }; } Emittion.EmitSerializeValue(emiter, il0, 1, typeof(MessagePackObject), null, NilImplication.MemberDefault, action4, localHolder); } });