private static MethodBuilder EmitBoxedSerializer(TypeBuilder type, int i, Type valueType, SerializerPair[] methodPairs, TypeModel model, Compiler.CompilerContext.ILVersion ilVersion, string assemblyName)
{
MethodInfo dedicated = methodPairs[i].Deserialize;
MethodBuilder boxedSerializer = type.DefineMethod("_" + i.ToString(), MethodAttributes.Static, CallingConventions.Standard,
model.MapType(typeof(object)), new Type[] { model.MapType(typeof(object)), model.MapType(typeof(ProtoReader)) });
Compiler.CompilerContext ctx = new Compiler.CompilerContext(boxedSerializer.GetILGenerator(), true, false, methodPairs, model, ilVersion, assemblyName, model.MapType(typeof(object)));
ctx.LoadValue(ctx.InputValue);
Compiler.CodeLabel @null = ctx.DefineLabel();
ctx.BranchIfFalse(@null, true);
Type mappedValueType = valueType;
ctx.LoadValue(ctx.InputValue);
ctx.CastFromObject(mappedValueType);
ctx.LoadReaderWriter();
ctx.EmitCall(dedicated);
ctx.CastToObject(mappedValueType);
ctx.Return();
ctx.MarkLabel(@null);
using (Compiler.Local typedVal = new Compiler.Local(ctx, mappedValueType))
{
// create a new valueType
ctx.LoadAddress(typedVal, mappedValueType);
ctx.EmitCtor(mappedValueType);
ctx.LoadValue(typedVal);
ctx.LoadReaderWriter();
ctx.EmitCall(dedicated);
ctx.CastToObject(mappedValueType);
ctx.Return();
}
return boxedSerializer;
}
private void WriteGetKeyImpl(TypeBuilder type, bool hasInheritance, SerializerPair[] methodPairs, Compiler.CompilerContext.ILVersion ilVersion, string assemblyName, out ILGenerator il, out int knownTypesCategory, out FieldBuilder knownTypes, out Type knownTypesLookupType)
{
il = Override(type, "GetKeyImpl");
Compiler.CompilerContext ctx = new Compiler.CompilerContext(il, false, false, methodPairs, this, ilVersion, assemblyName, MapType(typeof(System.Type), true));
if (types.Count <= KnownTypes_ArrayCutoff)
{
knownTypesCategory = KnownTypes_Array;
knownTypesLookupType = MapType(typeof(System.Type[]), true);
}
else
{
#if NO_GENERICS
knownTypesLookupType = null;
#else
knownTypesLookupType = MapType(typeof(System.Collections.Generic.Dictionary<System.Type, int>), false);
#endif
if (knownTypesLookupType == null)
{
knownTypesLookupType = MapType(typeof(Hashtable), true);
knownTypesCategory = KnownTypes_Hashtable;
}
else
{
knownTypesCategory = KnownTypes_Dictionary;
}
}
knownTypes = type.DefineField("knownTypes", knownTypesLookupType, FieldAttributes.Private | FieldAttributes.InitOnly | FieldAttributes.Static);
switch (knownTypesCategory)
{
case KnownTypes_Array:
{
il.Emit(OpCodes.Ldsfld, knownTypes);
il.Emit(OpCodes.Ldarg_1);
// note that Array.IndexOf is not supported under CF
il.EmitCall(OpCodes.Callvirt, MapType(typeof(IList)).GetMethod(
"IndexOf", new Type[] { MapType(typeof(object)) }), null);
if (hasInheritance)
{
il.DeclareLocal(MapType(typeof(int))); // loc-0
il.Emit(OpCodes.Dup);
il.Emit(OpCodes.Stloc_0);
BasicList getKeyLabels = new BasicList();
int lastKey = -1;
for (int i = 0; i < methodPairs.Length; i++)
{
if (methodPairs[i].MetaKey == methodPairs[i].BaseKey) break;
if (lastKey == methodPairs[i].BaseKey)
{ // add the last label again
getKeyLabels.Add(getKeyLabels[getKeyLabels.Count - 1]);
}
else
{ // add a new unique label
getKeyLabels.Add(ctx.DefineLabel());
lastKey = methodPairs[i].BaseKey;
}
}
Compiler.CodeLabel[] subtypeLabels = new Compiler.CodeLabel[getKeyLabels.Count];
getKeyLabels.CopyTo(subtypeLabels, 0);
ctx.Switch(subtypeLabels);
il.Emit(OpCodes.Ldloc_0); // not a sub-type; use the original value
il.Emit(OpCodes.Ret);
lastKey = -1;
// now output the different branches per sub-type (not derived type)
for (int i = subtypeLabels.Length - 1; i >= 0; i--)
{
if (lastKey != methodPairs[i].BaseKey)
{
lastKey = methodPairs[i].BaseKey;
// find the actual base-index for this base-key (i.e. the index of
// the base-type)
int keyIndex = -1;
for (int j = subtypeLabels.Length; j < methodPairs.Length; j++)
{
if (methodPairs[j].BaseKey == lastKey && methodPairs[j].MetaKey == lastKey)
{
keyIndex = j;
break;
}
}
ctx.MarkLabel(subtypeLabels[i]);
Compiler.CompilerContext.LoadValue(il, keyIndex);
il.Emit(OpCodes.Ret);
}
}
}
else
{
il.Emit(OpCodes.Ret);
}
}
break;
case KnownTypes_Dictionary:
{
LocalBuilder result = il.DeclareLocal(MapType(typeof(int)));
Label otherwise = il.DefineLabel();
il.Emit(OpCodes.Ldsfld, knownTypes);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Ldloca_S, result);
il.EmitCall(OpCodes.Callvirt, knownTypesLookupType.GetMethod("TryGetValue", BindingFlags.Instance | BindingFlags.Public), null);
il.Emit(OpCodes.Brfalse_S, otherwise);
il.Emit(OpCodes.Ldloc_S, result);
il.Emit(OpCodes.Ret);
il.MarkLabel(otherwise);
il.Emit(OpCodes.Ldc_I4_M1);
il.Emit(OpCodes.Ret);
}
break;
case KnownTypes_Hashtable:
{
Label otherwise = il.DefineLabel();
il.Emit(OpCodes.Ldsfld, knownTypes);
il.Emit(OpCodes.Ldarg_1);
il.EmitCall(OpCodes.Callvirt, knownTypesLookupType.GetProperty("Item").GetGetMethod(), null);
il.Emit(OpCodes.Dup);
il.Emit(OpCodes.Brfalse_S, otherwise);
#if FX11
il.Emit(OpCodes.Unbox, MapType(typeof(int)));
il.Emit(OpCodes.Ldobj, MapType(typeof(int)));
#else
if (ilVersion == Compiler.CompilerContext.ILVersion.Net1)
{
il.Emit(OpCodes.Unbox, MapType(typeof(int)));
il.Emit(OpCodes.Ldobj, MapType(typeof(int)));
}
else
{
il.Emit(OpCodes.Unbox_Any, MapType(typeof(int)));
}
#endif
il.Emit(OpCodes.Ret);
il.MarkLabel(otherwise);
il.Emit(OpCodes.Pop);
il.Emit(OpCodes.Ldc_I4_M1);
il.Emit(OpCodes.Ret);
}
break;
default:
throw new InvalidOperationException();
}
}
private Compiler.CompilerContext WriteSerializeDeserialize(string assemblyName, TypeBuilder type, SerializerPair[] methodPairs, Compiler.CompilerContext.ILVersion ilVersion, ref ILGenerator il)
{
il = Override(type, "Serialize");
Compiler.CompilerContext ctx = new Compiler.CompilerContext(il, false, true, methodPairs, this, ilVersion, assemblyName, MapType(typeof(object)));
// arg0 = this, arg1 = key, arg2=obj, arg3=dest
Compiler.CodeLabel[] jumpTable = new Compiler.CodeLabel[types.Count];
for (int i = 0; i < jumpTable.Length; i++)
{
jumpTable[i] = ctx.DefineLabel();
}
il.Emit(OpCodes.Ldarg_1);
ctx.Switch(jumpTable);
ctx.Return();
for (int i = 0; i < jumpTable.Length; i++)
{
SerializerPair pair = methodPairs[i];
ctx.MarkLabel(jumpTable[i]);
il.Emit(OpCodes.Ldarg_2);
ctx.CastFromObject(pair.Type.Type);
il.Emit(OpCodes.Ldarg_3);
il.EmitCall(OpCodes.Call, pair.Serialize, null);
ctx.Return();
}
il = Override(type, "Deserialize");
ctx = new Compiler.CompilerContext(il, false, false, methodPairs, this, ilVersion, assemblyName, MapType(typeof(object)));
// arg0 = this, arg1 = key, arg2=obj, arg3=source
for (int i = 0; i < jumpTable.Length; i++)
{
jumpTable[i] = ctx.DefineLabel();
}
il.Emit(OpCodes.Ldarg_1);
ctx.Switch(jumpTable);
ctx.LoadNullRef();
ctx.Return();
for (int i = 0; i < jumpTable.Length; i++)
{
SerializerPair pair = methodPairs[i];
ctx.MarkLabel(jumpTable[i]);
Type keyType = pair.Type.Type;
if (keyType.IsValueType)
{
il.Emit(OpCodes.Ldarg_2);
il.Emit(OpCodes.Ldarg_3);
il.EmitCall(OpCodes.Call, EmitBoxedSerializer(type, i, keyType, methodPairs, this, ilVersion, assemblyName), null);
ctx.Return();
}
else
{
il.Emit(OpCodes.Ldarg_2);
ctx.CastFromObject(keyType);
il.Emit(OpCodes.Ldarg_3);
il.EmitCall(OpCodes.Call, pair.Deserialize, null);
ctx.Return();
}
}
return ctx;
}
private static MethodBuilder EmitBoxedSerializer(TypeBuilder type, int i, Type valueType, SerializerPair[] methodPairs)
{
MethodInfo dedicated = methodPairs[i].Deserialize;
MethodBuilder boxedSerializer = type.DefineMethod("_" + i, MethodAttributes.Static, CallingConventions.Standard,
typeof(object), new Type[] { typeof(object), typeof(ProtoReader) });
Compiler.CompilerContext ctx = new Compiler.CompilerContext(boxedSerializer.GetILGenerator(), true, false, methodPairs);
ctx.LoadValue(Compiler.Local.InputValue);
Compiler.CodeLabel @null = ctx.DefineLabel();
ctx.BranchIfFalse(@null, true);
ctx.LoadValue(Compiler.Local.InputValue);
ctx.CastFromObject(valueType);
ctx.LoadReaderWriter();
ctx.EmitCall(dedicated);
ctx.CastToObject(valueType);
ctx.Return();
ctx.MarkLabel(@null);
using(Compiler.Local typedVal = new Compiler.Local(ctx, valueType))
{
// create a new valueType
ctx.LoadAddress(typedVal, valueType);
ctx.EmitCtor(valueType);
ctx.LoadValue(typedVal);
ctx.LoadReaderWriter();
ctx.EmitCall(dedicated);
ctx.CastToObject(valueType);
ctx.Return();
}
return boxedSerializer;
}
private void EmitWriteArrayLoop(Compiler.CompilerContext ctx, Compiler.Local i, Compiler.Local arr)
{
// i = 0
ctx.LoadValue(0);
ctx.StoreValue(i);
// range test is last (to minimise branches)
Compiler.CodeLabel loopTest = ctx.DefineLabel(), processItem = ctx.DefineLabel();
ctx.Branch(loopTest, false);
ctx.MarkLabel(processItem);
// {...}
ctx.LoadArrayValue(arr, i);
if (SupportNull)
{
Tail.EmitWrite(ctx, null);
}
else
{
ctx.WriteNullCheckedTail(itemType, Tail, null);
}
// i++
ctx.LoadValue(i);
ctx.LoadValue(1);
ctx.Add();
ctx.StoreValue(i);
// i < arr.Length
ctx.MarkLabel(loopTest);
ctx.LoadValue(i);
ctx.LoadLength(arr, false);
ctx.BranchIfLess(processItem, false);
}
protected override void EmitRead(Compiler.CompilerContext ctx, Compiler.Local valueFrom)
{
using (Compiler.Local oldList = AppendToCollection ? ctx.GetLocalWithValue(ExpectedType, valueFrom) : null)
using (Compiler.Local builder = new Compiler.Local(ctx, builderFactory.ReturnType))
{
ctx.EmitCall(builderFactory);
ctx.StoreValue(builder);
if (AppendToCollection)
{
Compiler.CodeLabel done = ctx.DefineLabel();
if (!ExpectedType.IsValueType)
{
ctx.LoadValue(oldList);
ctx.BranchIfFalse(done, false); // old value null; nothing to add
}
PropertyInfo prop = Helpers.GetProperty(ExpectedType, "Length", false);
if (prop == null)
{
prop = Helpers.GetProperty(ExpectedType, "Count", false);
}
#if !NO_GENERICS
if (prop == null)
{
prop = Helpers.GetProperty(ResolveIReadOnlyCollection(ExpectedType, Tail.ExpectedType), "Count", false);
}
#endif
ctx.LoadAddress(oldList, oldList.Type);
ctx.EmitCall(Helpers.GetGetMethod(prop, false, false));
ctx.BranchIfFalse(done, false); // old list is empty; nothing to add
Type voidType = ctx.MapType(typeof(void));
if (addRange != null)
{
ctx.LoadValue(builder);
ctx.LoadValue(oldList);
ctx.EmitCall(addRange);
if (addRange.ReturnType != null && add.ReturnType != voidType)
{
ctx.DiscardValue();
}
}
else
{
// loop and call Add repeatedly
MethodInfo moveNext, current, getEnumerator = GetEnumeratorInfo(ctx.Model, out moveNext, out current);
Helpers.DebugAssert(moveNext != null);
Helpers.DebugAssert(current != null);
Helpers.DebugAssert(getEnumerator != null);
Type enumeratorType = getEnumerator.ReturnType;
using (Compiler.Local iter = new Compiler.Local(ctx, enumeratorType))
{
ctx.LoadAddress(oldList, ExpectedType);
ctx.EmitCall(getEnumerator);
ctx.StoreValue(iter);
using (ctx.Using(iter))
{
Compiler.CodeLabel body = ctx.DefineLabel(), next = ctx.DefineLabel();
ctx.Branch(next, false);
ctx.MarkLabel(body);
ctx.LoadAddress(builder, builder.Type);
ctx.LoadAddress(iter, enumeratorType);
ctx.EmitCall(current);
ctx.EmitCall(add);
if (add.ReturnType != null && add.ReturnType != voidType)
{
ctx.DiscardValue();
}
ctx.MarkLabel(@next);
ctx.LoadAddress(iter, enumeratorType);
ctx.EmitCall(moveNext);
ctx.BranchIfTrue(body, false);
}
}
}
ctx.MarkLabel(done);
}
EmitReadList(ctx, builder, Tail, add, packedWireType, false);
ctx.LoadAddress(builder, builder.Type);
ctx.EmitCall(finish);
if (ExpectedType != finish.ReturnType)
{
ctx.Cast(ExpectedType);
}
}
}
