public static void EmitUnpackerEndReadSubtree(TracingILGenerator il, LocalBuilder subtreeUnpacker)
{
Contract.Requires(il != null);
Contract.Requires(subtreeUnpacker != null);
/*
* finally
* {
* if( subtreeUnpacker != null )
* {
* subtreeUnpacker.Dispose();
* }
* }
*/
il.BeginFinallyBlock();
il.EmitAnyLdloc(subtreeUnpacker);
var endIf = il.DefineLabel("END_IF");
il.EmitBrfalse_S(endIf);
il.EmitAnyLdloc(subtreeUnpacker);
il.EmitAnyCall(Metadata._IDisposable.Dispose);
il.MarkLabel(endIf);
il.EndExceptionBlock();
}
public static void EmitUnpackerEndReadSubtree(TracingILGenerator il, LocalBuilder subtreeUnpacker)
{
Contract.Requires(il != null);
Contract.Requires(subtreeUnpacker != null);
il.BeginFinallyBlock();
il.EmitAnyLdloc(subtreeUnpacker);
Label target = il.DefineLabel("END_IF");
il.EmitBrfalse_S(target);
il.EmitAnyLdloc(subtreeUnpacker);
il.EmitAnyCall(_IDisposable.Dispose);
il.MarkLabel(target);
il.EndExceptionBlock();
}
public static void EmitNilImplication(TracingILGenerator il, int unpackerArgumentIndex, string memberName, NilImplication nilImplication, Label endOfDeserialization, LocalVariableHolder localHolder)
{
LocalBuilder unpackedData;
LocalBuilder unpackedDataValue;
switch (nilImplication)
{
case NilImplication.MemberDefault:
il.EmitAnyLdarg(unpackerArgumentIndex);
il.EmitGetProperty(_Unpacker.Data);
unpackedData = localHolder.UnpackedData;
il.EmitAnyStloc(unpackedData);
il.EmitAnyLdloca(unpackedData);
il.EmitGetProperty(_Nullable <MessagePackObject> .Value);
unpackedDataValue = localHolder.UnpackedDataValue;
il.EmitAnyStloc(unpackedDataValue);
il.EmitAnyLdloca(unpackedDataValue);
il.EmitGetProperty(_MessagePackObject.IsNil);
il.EmitBrtrue(endOfDeserialization);
break;
case NilImplication.Prohibit:
{
il.EmitAnyLdarg(unpackerArgumentIndex);
il.EmitGetProperty(_Unpacker.Data);
unpackedData = localHolder.UnpackedData;
il.EmitAnyStloc(unpackedData);
il.EmitAnyLdloca(unpackedData);
il.EmitGetProperty(_Nullable <MessagePackObject> .Value);
unpackedDataValue = localHolder.UnpackedDataValue;
il.EmitAnyStloc(unpackedDataValue);
il.EmitAnyLdloca(unpackedDataValue);
il.EmitGetProperty(_MessagePackObject.IsNil);
Label target = il.DefineLabel("END_IF0");
il.EmitBrfalse_S(target);
il.EmitLdstr(memberName);
il.EmitAnyCall(SerializationExceptions.NewNullIsProhibitedMethod);
il.EmitThrow();
il.MarkLabel(target);
break;
}
}
}
private static void EmitCompareNull(TracingILGenerator il, LocalBuilder value, Label targetIfNotNull)
{
if (value.LocalType == typeof(MessagePackObject))
{
il.EmitAnyLdloca(value);
il.EmitGetProperty(_MessagePackObject.IsNil);
il.EmitBrfalse_S(targetIfNotNull);
}
else if (value.LocalType.GetIsValueType())
{
Contract.Assert(Nullable.GetUnderlyingType(value.LocalType) != null, value.LocalType.FullName);
il.EmitAnyLdloca(value);
il.EmitGetProperty(value.LocalType.GetProperty("HasValue"));
il.EmitBrtrue_S(targetIfNotNull);
}
else
{
il.EmitAnyLdloc(value);
il.EmitLdnull();
il.EmitBne_Un_S(targetIfNotNull);
}
}
private static void CreateUnpacking(SerializerEmitter emitter)
{
TracingILGenerator unpackFromMethodILGenerator = emitter.GetUnpackFromMethodILGenerator();
try
{
LocalBuilder local = unpackFromMethodILGenerator.DeclareLocal(typeof(MessagePackObject?), "mayBeNullData");
LocalBuilder builder2 = unpackFromMethodILGenerator.DeclareLocal(typeof(MessagePackObject), "data");
LocalBuilder builder3 = unpackFromMethodILGenerator.DeclareLocal(typeof(T), "result");
LocalBuilder result = unpackFromMethodILGenerator.DeclareLocal(NullableMessagePackSerializer <T> ._nullableTValueProperty.PropertyType, "value");
Label target = unpackFromMethodILGenerator.DefineLabel("END_IF");
Label label2 = unpackFromMethodILGenerator.DefineLabel("END_METHOD");
unpackFromMethodILGenerator.EmitAnyLdarg(1);
unpackFromMethodILGenerator.EmitGetProperty(NullableMessagePackSerializer.UnpackerDataProperty);
unpackFromMethodILGenerator.EmitAnyStloc(local);
unpackFromMethodILGenerator.EmitAnyLdloca(local);
unpackFromMethodILGenerator.EmitGetProperty(NullableMessagePackSerializer.Nullable_MessagePackObject_ValueProperty);
unpackFromMethodILGenerator.EmitAnyStloc(builder2);
unpackFromMethodILGenerator.EmitAnyLdloca(builder2);
unpackFromMethodILGenerator.EmitGetProperty(NullableMessagePackSerializer.MessagePackObject_IsNilProperty);
unpackFromMethodILGenerator.EmitBrfalse_S(target);
unpackFromMethodILGenerator.EmitAnyLdloca(builder3);
unpackFromMethodILGenerator.EmitInitobj(builder3.LocalType);
unpackFromMethodILGenerator.EmitBr_S(label2);
unpackFromMethodILGenerator.MarkLabel(target);
Emittion.EmitUnpackFrom(emitter, unpackFromMethodILGenerator, result, 1);
unpackFromMethodILGenerator.EmitAnyLdloc(result);
unpackFromMethodILGenerator.EmitAnyCall(NullableMessagePackSerializer <T> ._nullableTImplicitOperator);
unpackFromMethodILGenerator.EmitAnyStloc(builder3);
unpackFromMethodILGenerator.MarkLabel(label2);
unpackFromMethodILGenerator.EmitAnyLdloc(builder3);
unpackFromMethodILGenerator.EmitRet();
}
finally
{
unpackFromMethodILGenerator.FlushTrace();
emitter.FlushTrace();
}
}
public static void EmitDeserializeCollectionValue(SerializerEmitter emitter, TracingILGenerator il, int unpackerArgumentIndex, LocalBuilder target, MemberInfo member, Type memberType, NilImplication nilImplication, LocalVariableHolder localHolder)
{
LocalBuilder unpackedData;
LocalBuilder unpackedDataValue;
Label label2;
Label label3;
Contract.Requires(emitter != null);
Contract.Requires(il != null);
Contract.Requires(unpackerArgumentIndex >= 0);
Contract.Requires(target != null);
Contract.Requires(member != null);
Contract.Requires(memberType != null);
Contract.Requires(localHolder != null);
Label label = il.DefineLabel("END_OF_DESERIALIZATION");
EmitGeneralRead(il, unpackerArgumentIndex);
switch (nilImplication)
{
case NilImplication.MemberDefault:
il.EmitAnyLdarg(unpackerArgumentIndex);
il.EmitGetProperty(_Unpacker.Data);
unpackedData = localHolder.UnpackedData;
il.EmitAnyStloc(unpackedData);
il.EmitAnyLdloca(unpackedData);
il.EmitGetProperty(_Nullable <MessagePackObject> .Value);
unpackedDataValue = localHolder.UnpackedDataValue;
il.EmitAnyStloc(unpackedDataValue);
il.EmitAnyLdloca(unpackedDataValue);
il.EmitGetProperty(_MessagePackObject.IsNil);
il.EmitBrtrue(label);
goto Label_01B5;
case NilImplication.Null:
case NilImplication.Prohibit:
il.EmitAnyLdarg(unpackerArgumentIndex);
il.EmitGetProperty(_Unpacker.Data);
unpackedData = localHolder.UnpackedData;
il.EmitAnyStloc(unpackedData);
il.EmitAnyLdloca(unpackedData);
il.EmitGetProperty(_Nullable <MessagePackObject> .Value);
unpackedDataValue = localHolder.UnpackedDataValue;
il.EmitAnyStloc(unpackedDataValue);
il.EmitAnyLdloca(unpackedDataValue);
il.EmitGetProperty(_MessagePackObject.IsNil);
label2 = il.DefineLabel("END_IF0");
il.EmitBrfalse_S(label2);
il.EmitLdstr(member.Name);
if (nilImplication != NilImplication.Prohibit)
{
il.EmitAnyCall(SerializationExceptions.NewReadOnlyMemberItemsMustNotBeNullMethod);
break;
}
il.EmitAnyCall(SerializationExceptions.NewNullIsProhibitedMethod);
break;
default:
goto Label_01B5;
}
il.EmitThrow();
il.MarkLabel(label2);
Label_01B5:
label3 = il.DefineLabel("THEN");
Action <TracingILGenerator, int> action = emitter.RegisterSerializer(memberType);
il.EmitAnyLdarg(unpackerArgumentIndex);
il.EmitGetProperty(_Unpacker.IsArrayHeader);
il.EmitBrtrue_S(label3);
il.EmitAnyLdarg(unpackerArgumentIndex);
il.EmitGetProperty(_Unpacker.IsMapHeader);
il.EmitBrtrue_S(label3);
il.EmitLdstr(member.Name);
il.EmitAnyCall(SerializationExceptions.NewStreamDoesNotContainCollectionForMemberMethod);
il.EmitThrow();
LocalBuilder subtreeUnpacker = localHolder.SubtreeUnpacker;
il.MarkLabel(label3);
EmitUnpackerBeginReadSubtree(il, unpackerArgumentIndex, subtreeUnpacker);
action(il, 0);
il.EmitAnyLdloc(subtreeUnpacker);
il.EmitAnyLdloc(target);
EmitLoadValue(il, member);
il.EmitAnyCall(typeof(MessagePackSerializer <>).MakeGenericType(new Type[] { memberType }).GetMethod("UnpackTo", new Type[] { typeof(Unpacker), memberType }));
EmitUnpackerEndReadSubtree(il, subtreeUnpacker);
il.MarkLabel(label);
}
/// <summary>
/// Emits the deserialize collection value.
/// </summary>
/// <param name="emitter">The emitter.</param>
/// <param name="il">The il generator.</param>
/// <param name="unpackerArgumentIndex">Index of the unpacker argument.</param>
/// <param name="target">The target collection variable.</param>
/// <param name="member">The deserializing member metadata which holds the collection.</param>
/// <param name="memberType">Type of the deserializing member.</param>
/// <param name="nilImplication">The nil implication.</param>
/// <param name="localHolder">The <see cref="LocalVariableHolder"/> which holds shared local variable information.</param>
public static void EmitDeserializeCollectionValue(SerializerEmitter emitter, TracingILGenerator il, int unpackerArgumentIndex, LocalBuilder target, MemberInfo member, Type memberType, NilImplication nilImplication, LocalVariableHolder localHolder)
{
Contract.Requires(emitter != null);
Contract.Requires(il != null);
Contract.Requires(unpackerArgumentIndex >= 0);
Contract.Requires(target != null);
Contract.Requires(member != null);
Contract.Requires(memberType != null);
Contract.Requires(localHolder != null);
var endOfDeserialization = il.DefineLabel("END_OF_DESERIALIZATION");
EmitGeneralRead(il, unpackerArgumentIndex);
switch (nilImplication)
{
case NilImplication.MemberDefault:
{
/*
* if( unpacker.Data.Value.IsNil )
* {
* // Skip current.
* goto END_OF_DESERIALIZATION;
* }
*/
il.EmitAnyLdarg(unpackerArgumentIndex);
il.EmitGetProperty(Metadata._Unpacker.Data);
var data = localHolder.UnpackedData;
il.EmitAnyStloc(data);
il.EmitAnyLdloca(data);
il.EmitGetProperty(Metadata._Nullable <MessagePackObject> .Value);
var dataValue = localHolder.UnpackedDataValue;
il.EmitAnyStloc(dataValue);
il.EmitAnyLdloca(dataValue);
il.EmitGetProperty(Metadata._MessagePackObject.IsNil);
il.EmitBrtrue(endOfDeserialization);
break;
}
case NilImplication.Null:
case NilImplication.Prohibit:
{
/*
* // for Prohibit
* if( unpacker.Data.Value.IsNil )
* {
* throw SerializationEceptions.NewProhibitNullException( "..." );
* }
*
* // for Null, and
* if( unpacker.Data.Value.IsNil )
* {
* throw SerializationEceptions.NewReadOnlyMemberItemsMustNotBeNullMethod( "..." );
* }
*/
il.EmitAnyLdarg(unpackerArgumentIndex);
il.EmitGetProperty(Metadata._Unpacker.Data);
var data = localHolder.UnpackedData;
il.EmitAnyStloc(data);
il.EmitAnyLdloca(data);
il.EmitGetProperty(Metadata._Nullable <MessagePackObject> .Value);
var dataValue = localHolder.UnpackedDataValue;
il.EmitAnyStloc(dataValue);
il.EmitAnyLdloca(dataValue);
il.EmitGetProperty(Metadata._MessagePackObject.IsNil);
var endIf0 = il.DefineLabel("END_IF0");
il.EmitBrfalse_S(endIf0);
il.EmitLdstr(member.Name);
if (nilImplication == NilImplication.Prohibit)
{
il.EmitAnyCall(SerializationExceptions.NewNullIsProhibitedMethod);
}
else
{
// Because result member is readonly collection, so the member will not be null if packed value was nil.
il.EmitAnyCall(SerializationExceptions.NewReadOnlyMemberItemsMustNotBeNullMethod);
}
il.EmitThrow();
il.MarkLabel(endIf0);
break;
}
}
/*
* if( !unpacker.IsArrayHeader && !unpacker.IsMapHeader )
* {
* throw new SerializatonException( "Cannot deserialize..." );
* }
*
* using( var subtreeUnpacker = unpacker.ReadSubtree() )
* {
* GET_SERIALIZER.UnpackTo( unpacker, result ) )
* }
*
* END_OF_DESERIALIZATION:
*/
var endIf = il.DefineLabel("THEN");
var serializerGetter = emitter.RegisterSerializer(memberType);
il.EmitAnyLdarg(unpackerArgumentIndex);
il.EmitGetProperty(Metadata._Unpacker.IsArrayHeader);
il.EmitBrtrue_S(endIf);
il.EmitAnyLdarg(unpackerArgumentIndex);
il.EmitGetProperty(Metadata._Unpacker.IsMapHeader);
il.EmitBrtrue_S(endIf);
// else
il.EmitLdstr(member.Name);
il.EmitAnyCall(SerializationExceptions.NewStreamDoesNotContainCollectionForMemberMethod);
il.EmitThrow();
// then
var subtreeUnpacker = localHolder.SubtreeUnpacker;
il.MarkLabel(endIf);
EmitUnpackerBeginReadSubtree(il, unpackerArgumentIndex, subtreeUnpacker);
serializerGetter(il, 0);
il.EmitAnyLdloc(subtreeUnpacker);
il.EmitAnyLdloc(target);
Emittion.EmitLoadValue(il, member);
il.EmitAnyCall(typeof(MessagePackSerializer <>).MakeGenericType(memberType).GetMethod("UnpackTo", new[] { typeof(Unpacker), memberType }));
EmitUnpackerEndReadSubtree(il, subtreeUnpacker);
il.MarkLabel(endOfDeserialization);
}
/// <summary>
/// Emits the nil implication.
/// </summary>
/// <param name="il">The il generator.</param>
/// <param name="unpackerArgumentIndex">Index of the unpacker argument.</param>
/// <param name="memberName">Name of the deserializing member.</param>
/// <param name="nilImplication">The nil implication.</param>
/// <param name="endOfDeserialization">The label to the end of deserialization.</param>
/// <param name="localHolder">The <see cref="LocalVariableHolder"/> which holds shared local variable information.</param>
public static void EmitNilImplication(
TracingILGenerator il,
int unpackerArgumentIndex,
string memberName,
NilImplication nilImplication,
Label endOfDeserialization,
LocalVariableHolder localHolder
)
{
switch (nilImplication)
{
case NilImplication.MemberDefault:
{
// TODO: This should be empty for extra items.
/*
* if( unpacker.Data.Value.IsNil )
* {
* // Skip current.
* goto END_OF_DESERIALIZATION;
* }
*/
il.EmitAnyLdarg(unpackerArgumentIndex);
il.EmitGetProperty(Metadata._Unpacker.Data);
var data = localHolder.UnpackedData;
il.EmitAnyStloc(data);
il.EmitAnyLdloca(data);
il.EmitGetProperty(Metadata._Nullable <MessagePackObject> .Value);
var dataValue = localHolder.UnpackedDataValue;
il.EmitAnyStloc(dataValue);
il.EmitAnyLdloca(dataValue);
il.EmitGetProperty(Metadata._MessagePackObject.IsNil);
il.EmitBrtrue(endOfDeserialization);
break;
}
case NilImplication.Prohibit:
{
/*
* if( unpacker.Data.Value.IsNil )
* {
* throw SerializationEceptions.NewProhibitNullException( "..." );
* }
*/
il.EmitAnyLdarg(unpackerArgumentIndex);
il.EmitGetProperty(Metadata._Unpacker.Data);
var data = localHolder.UnpackedData;
il.EmitAnyStloc(data);
il.EmitAnyLdloca(data);
il.EmitGetProperty(Metadata._Nullable <MessagePackObject> .Value);
var dataValue = localHolder.UnpackedDataValue;
il.EmitAnyStloc(dataValue);
il.EmitAnyLdloca(dataValue);
il.EmitGetProperty(Metadata._MessagePackObject.IsNil);
var endIf0 = il.DefineLabel("END_IF0");
il.EmitBrfalse_S(endIf0);
il.EmitLdstr(memberName);
il.EmitAnyCall(SerializationExceptions.NewNullIsProhibitedMethod);
il.EmitThrow();
il.MarkLabel(endIf0);
break;
}
}
}
/// <summary>
/// Emits the nil implication.
/// </summary>
/// <param name="il">The il generator.</param>
/// <param name="unpackerArgumentIndex">Index of the unpacker argument.</param>
/// <param name="member">Metadata of the serializing member.</param>
/// <param name="endOfDeserialization">The label to the end of deserialization.</param>
/// <param name="localHolder">The <see cref="LocalVariableHolder"/> which holds shared local variable information.</param>
public static void EmitNilImplication(
TracingILGenerator il,
int unpackerArgumentIndex,
SerializingMember member,
Label endOfDeserialization,
LocalVariableHolder localHolder
)
{
switch (member.Contract.NilImplication)
{
case NilImplication.MemberDefault:
{
// TODO: This should be empty for extra items.
/*
* if( unpacker.Data.Value.IsNil )
* {
* // Skip current.
* goto END_OF_DESERIALIZATION;
* }
*/
il.EmitAnyLdarg(unpackerArgumentIndex);
il.EmitGetProperty(Metadata._Unpacker.LastReadData);
var data = localHolder.UnpackedData;
il.EmitAnyStloc(data);
il.EmitAnyLdloca(data);
il.EmitGetProperty(Metadata._MessagePackObject.IsNil);
il.EmitBrtrue(endOfDeserialization);
break;
}
case NilImplication.Null:
{
if (member.Member.GetMemberValueType().GetIsValueType() && Nullable.GetUnderlyingType(member.Member.GetMemberValueType()) == null)
{
throw SerializationExceptions.NewValueTypeCannotBeNull(
member.Contract.Name, member.Member.GetMemberValueType(), member.Member.DeclaringType
);
}
if (!member.Member.CanSetValue())
{
throw SerializationExceptions.NewReadOnlyMemberItemsMustNotBeNull(
member.Contract.Name
);
}
break;
}
case NilImplication.Prohibit:
{
if (!member.Member.CanSetValue())
{
throw SerializationExceptions.NewReadOnlyMemberItemsMustNotBeNull(
member.Contract.Name
);
}
/*
* if( unpacker.Data.Value.IsNil )
* {
* throw SerializationEceptions.NewProhibitNullException( "..." );
* }
*/
il.EmitAnyLdarg(unpackerArgumentIndex);
il.EmitGetProperty(Metadata._Unpacker.LastReadData);
var data = localHolder.UnpackedData;
il.EmitAnyStloc(data);
il.EmitAnyLdloca(data);
il.EmitGetProperty(Metadata._MessagePackObject.IsNil);
var endIf0 = il.DefineLabel("END_IF0");
il.EmitBrfalse_S(endIf0);
il.EmitLdstr(member.Contract.Name);
il.EmitAnyCall(SerializationExceptions.NewNullIsProhibitedMethod);
il.EmitThrow();
il.MarkLabel(endIf0);
break;
}
}
}