void IProtoSerializer.EmitWrite(Compiler.CompilerContext ctx, Compiler.Local valueFrom)
{
if (!EmitDedicatedMethod(ctx, valueFrom, false))
{
ctx.LoadValue(valueFrom);
if (type.IsValueType)
{
ctx.CastToObject(type);
}
ctx.LoadValue(key);
ctx.LoadReaderWriter();
ctx.EmitCall(ctx.MapType(typeof(ProtoWriter)).GetMethod(recursionCheck ? "WriteObject" : "WriteRecursionSafeObject"));
}
}
void IProtoSerializer.EmitWrite(Compiler.CompilerContext ctx, Compiler.Local valueFrom)
{
if (!EmitDedicatedMethod(ctx, valueFrom, false))
{
ctx.LoadValue(valueFrom);
if (Helpers.IsValueType(type))
{
ctx.CastToObject(type);
}
ctx.LoadValue(ctx.MapMetaKeyToCompiledKey(key)); // re-map for formality, but would expect identical, else dedicated method
ctx.LoadReaderWriter();
ctx.EmitCall(Helpers.GetStaticMethod(ctx.MapType(typeof(ProtoWriter)), recursionCheck ? "WriteObject" : "WriteRecursionSafeObject", new Type[] { ctx.MapType(typeof(object)), ctx.MapType(typeof(int)), ctx.MapType(typeof(ProtoWriter)) }));
}
}
void IProtoSerializer.EmitRead(Compiler.CompilerContext ctx, Compiler.Local valueFrom)
{
if (!EmitDedicatedMethod(ctx, valueFrom, true))
{
ctx.LoadValue(valueFrom);
if (type.IsValueType)
{
ctx.CastToObject(type);
}
ctx.LoadValue(key);
ctx.LoadReaderWriter();
ctx.EmitCall(typeof(ProtoReader).GetMethod("ReadObject"));
ctx.CastFromObject(type);
}
}
void IProtoSerializer.EmitRead(Compiler.CompilerContext ctx, Compiler.Local valueFrom)
{
if (!EmitDedicatedMethod(ctx, valueFrom, true))
{
ctx.LoadValue(valueFrom);
if (Helpers.IsValueType(type))
{
ctx.CastToObject(type);
}
ctx.LoadValue(ctx.MapMetaKeyToCompiledKey(key)); // re-map for formality, but would expect identical, else dedicated method
ctx.LoadReaderWriter();
ctx.EmitCall(Helpers.GetStaticMethod(ctx.MapType(typeof(ProtoReader)), "ReadObject"));
ctx.CastFromObject(type);
}
}
public void EmitWrite(Compiler.CompilerContext ctx, Compiler.Local valueFrom)
{
ctx.LoadValue(valueFrom);
ctx.CastToObject(type);
ctx.LoadReaderWriter();
ctx.LoadValue(ctx.MapMetaKeyToCompiledKey(key));
ctx.LoadValue((int)options);
ctx.EmitCall(ctx.MapType(typeof(BclHelpers)).GetMethod("WriteNetObject"));
}
void IProtoSerializer.EmitWrite(Compiler.CompilerContext ctx, Compiler.Local valueFrom)
{
using (ctx.StartDebugBlockAuto(this))
{
if (!EmitDedicatedMethod(ctx, valueFrom, false))
{
ctx.LoadValue(valueFrom);
if (ExpectedType.IsValueType)
{
ctx.CastToObject(ExpectedType);
}
ctx.LoadValue(ctx.MapMetaKeyToCompiledKey(_baseKey)); // re-map for formality, but would expect identical, else dedicated method
ctx.LoadReaderWriter();
ctx.EmitCall(ctx.MapType(typeof(ProtoWriter)).GetMethod("WriteRecursionSafeObject"));
}
}
}
public void EmitRead(Compiler.CompilerContext ctx, Compiler.Local valueFrom)
{
ctx.LoadValue(valueFrom);
ctx.CastToObject(type);
ctx.LoadReaderWriter();
ctx.LoadValue(key);
if (type == typeof(object))
{
ctx.LoadNullRef();
}
else
{
ctx.LoadValue(type);
}
ctx.EmitCall(typeof(BclHelpers).GetMethod("ReadNetObject"));
ctx.CastFromObject(type);
}
public void EmitRead(Compiler.CompilerContext ctx, Compiler.Local valueFrom)
{
ctx.LoadValue(valueFrom);
ctx.CastToObject(type);
ctx.LoadReaderWriter();
ctx.LoadValue(ctx.MapMetaKeyToCompiledKey(key));
if (type == ctx.MapType(typeof(object)))
{
ctx.LoadNullRef();
}
else
{
ctx.LoadValue(type);
}
ctx.LoadValue((int)options);
ctx.EmitCall(ctx.MapType(typeof(BclHelpers)).GetMethod("ReadNetObject"));
ctx.CastFromObject(type);
}
void IProtoSerializer.EmitWrite(Compiler.CompilerContext ctx, Compiler.Local valueFrom)
{
using (ctx.StartDebugBlockAuto(this))
{
ProtoTypeCode typeCode = GetTypeCode();
if (_map == null)
{
ctx.LoadValue(valueFrom);
ctx.ConvertToInt32(typeCode, false);
ctx.EmitBasicWrite("WriteInt32", null);
}
else
{
using (Compiler.Local loc = ctx.GetLocalWithValue(ExpectedType, valueFrom))
{
Compiler.CodeLabel @continue = ctx.DefineLabel();
for (int i = 0; i < _map.Length; i++)
{
Compiler.CodeLabel tryNextValue = ctx.DefineLabel(), processThisValue = ctx.DefineLabel();
ctx.LoadValue(loc);
WriteEnumValue(ctx, typeCode, _map[i].RawValue);
ctx.BranchIfEqual(processThisValue, true);
ctx.Branch(tryNextValue, true);
ctx.MarkLabel(processThisValue);
ctx.LoadValue(_map[i].WireValue);
ctx.EmitBasicWrite("WriteInt32", null);
ctx.Branch(@continue, false);
ctx.MarkLabel(tryNextValue);
}
ctx.LoadReaderWriter();
ctx.LoadValue(loc);
ctx.CastToObject(ExpectedType);
ctx.EmitCall(ctx.MapType(typeof(ProtoWriter)).GetMethod("ThrowEnumException"));
ctx.MarkLabel(@continue);
}
}
}
}
public void EmitRead(Compiler.CompilerContext ctx, Compiler.Local entity)
{
using (var val = ctx.GetLocalWithValue(ExpectedType, entity))
{
ctx.LoadReader(true);
ctx.LoadValue(val);
ctx.CastToObject(ExpectedType);
ctx.LoadValue(ctx.MapMetaKeyToCompiledKey(key));
if (ExpectedType == typeof(object))
{
ctx.LoadNullRef();
}
else
{
ctx.LoadValue(ExpectedType);
}
ctx.LoadValue((int)options);
ctx.EmitCall(typeof(BclHelpers).GetMethod("ReadNetObject",
new[] { typeof(ProtoReader), Compiler.ReaderUtil.ByRefStateType, typeof(object),
typeof(int), typeof(Type), typeof(BclHelpers.NetObjectOptions) }));
ctx.CastFromObject(ExpectedType);
}
}
private static void EmitReadAndAddItem(Compiler.CompilerContext ctx, Compiler.Local list, IProtoSerializer tail, MethodInfo add, bool castListForAdd)
{
ctx.LoadAddress(list, list.Type); // needs to be the reference in case the list is value-type (static-call)
if (castListForAdd)
{
ctx.Cast(add.DeclaringType);
}
Type itemType = tail.ExpectedType;
bool tailReturnsValue = tail.ReturnsValue;
if (tail.RequiresOldValue)
{
if (itemType.IsValueType || !tailReturnsValue)
{
// going to need a variable
using (Compiler.Local item = new Compiler.Local(ctx, itemType))
{
if (itemType.IsValueType)
{ // initialise the struct
ctx.LoadAddress(item, itemType);
ctx.EmitCtor(itemType);
}
else
{ // assign null
ctx.LoadNullRef();
ctx.StoreValue(item);
}
tail.EmitRead(ctx, item);
if (!tailReturnsValue)
{
ctx.LoadValue(item);
}
}
}
else
{ // no variable; pass the null on the stack and take the value *off* the stack
ctx.LoadNullRef();
tail.EmitRead(ctx, null);
}
}
else
{
if (tailReturnsValue)
{ // out only (on the stack); just emit it
tail.EmitRead(ctx, null);
}
else
{ // doesn't take anything in nor return anything! WTF?
throw new InvalidOperationException();
}
}
// our "Add" is chosen either to take the correct type, or to take "object";
// we may need to box the value
Type addParamType = add.GetParameters()[0].ParameterType;
if (addParamType != itemType)
{
if (addParamType == ctx.MapType(typeof(object)))
{
ctx.CastToObject(itemType);
}
else if (Helpers.GetUnderlyingType(addParamType) == itemType)
{ // list is nullable
ConstructorInfo ctor = Helpers.GetConstructor(addParamType, new Type[] { itemType }, false);
ctx.EmitCtor(ctor); // the itemType on the stack is now a Nullable<ItemType>
}
else
{
throw new InvalidOperationException("Conflicting item/add type");
}
}
ctx.EmitCall(add);
if (add.ReturnType != ctx.MapType(typeof(void)))
{
ctx.DiscardValue();
}
}
private void WriteFieldHandler(
Compiler.CompilerContext ctx, Type expected, Compiler.Local loc,
Compiler.CodeLabel handler, Compiler.CodeLabel @continue, IProtoSerializer serializer)
{
ctx.MarkLabel(handler);
Type serType = serializer.ExpectedType;
if (serType == ExpectedType)
{
EmitCreateIfNull(ctx, loc);
serializer.EmitRead(ctx, loc);
}
else
{
//RuntimeTypeModel rtm = (RuntimeTypeModel)ctx.Model;
if (((IProtoTypeSerializer)serializer).CanCreateInstance())
{
Compiler.CodeLabel allDone = ctx.DefineLabel();
ctx.LoadValue(loc);
ctx.BranchIfFalse(allDone, false); // null is always ok
ctx.LoadValue(loc);
ctx.TryCast(serType);
ctx.BranchIfTrue(allDone, false); // not null, but of the correct type
// otherwise, need to convert it
ctx.LoadReader(false);
ctx.LoadValue(loc);
((IProtoTypeSerializer)serializer).EmitCreateInstance(ctx);
ctx.EmitCall(typeof(ProtoReader).GetMethod("Merge",
new[] { typeof(ProtoReader), typeof(object), typeof(object) }));
ctx.Cast(expected);
ctx.StoreValue(loc); // Merge always returns a value
// nothing needs doing
ctx.MarkLabel(allDone);
}
if (Helpers.IsValueType(serType))
{
Compiler.CodeLabel initValue = ctx.DefineLabel();
Compiler.CodeLabel hasValue = ctx.DefineLabel();
using (Compiler.Local emptyValue = new Compiler.Local(ctx, serType))
{
ctx.LoadValue(loc);
ctx.BranchIfFalse(initValue, false);
ctx.LoadValue(loc);
ctx.CastFromObject(serType);
ctx.Branch(hasValue, false);
ctx.MarkLabel(initValue);
ctx.InitLocal(serType, emptyValue);
ctx.LoadValue(emptyValue);
ctx.MarkLabel(hasValue);
}
}
else
{
ctx.LoadValue(loc);
ctx.Cast(serType);
}
serializer.EmitRead(ctx, null);
}
if (serializer.ReturnsValue)
{ // update the variable
if (Helpers.IsValueType(serType))
{
// but box it first in case of value type
ctx.CastToObject(serType);
}
ctx.StoreValue(loc);
}
ctx.Branch(@continue, false); // "continue"
}
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 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 static void EmitReadAndAddItem(Compiler.CompilerContext ctx, Compiler.Local list, IProtoSerializer tail, MethodInfo add)
{
ctx.LoadValue(list);
Type itemType = tail.ExpectedType;
if (tail.RequiresOldValue)
{
if (itemType.IsValueType || !tail.ReturnsValue)
{
// going to need a variable
using (Compiler.Local item = new Compiler.Local(ctx, itemType))
{
if (itemType.IsValueType)
{ // initialise the struct
ctx.LoadAddress(item, itemType);
ctx.EmitCtor(itemType);
}
else
{ // assign null
ctx.LoadNullRef();
ctx.StoreValue(item);
}
tail.EmitRead(ctx, item);
if (!tail.ReturnsValue)
{
ctx.LoadValue(item);
}
}
}
else
{ // no variable; pass the null on the stack and take the value *off* the stack
ctx.LoadNullRef();
tail.EmitRead(ctx, null);
}
}
else
{
if (tail.ReturnsValue)
{ // out only (on the stack); just emit it
tail.EmitRead(ctx, null);
}
else
{ // doesn't take anything in nor return anything! WTF?
throw new InvalidOperationException();
}
}
// our "Add" is chosen either to take the correct type, or to take "object";
// we may need to box the value
Type addParamType = add.GetParameters()[0].ParameterType;
if (addParamType != itemType)
{
if (addParamType == typeof(object))
{
ctx.CastToObject(itemType);
}
else
{
throw new InvalidOperationException("Conflicting item/add type");
}
}
ctx.EmitCall(add);
if (add.ReturnType != typeof(void))
{
ctx.DiscardValue();
}
}
public void EmitRead(Compiler.CompilerContext ctx, Compiler.Local incoming)
{
using (ctx.StartDebugBlockAuto(this))
{
var g = ctx.G;
using (Compiler.Local objValue = ctx.GetLocalWithValueForEmitRead(this, incoming))
using (Compiler.Local reservedTrap = new Local(ctx, ctx.MapType(typeof(int))))
using (Compiler.Local token = new Local(ctx, ctx.MapType(typeof(SubItemToken))))
using (Compiler.Local refLocalToNoteObject = new Local(ctx, ctx.MapType(typeof(object))))
{
ctx.EmitCallReserveNoteObject();
ctx.StoreValue(reservedTrap);
Compiler.Local[] locals = new Compiler.Local[_members.Length];
try
{
g.Assign(token, g.ReaderFunc.StartSubItem());
for (int i = 0; i < locals.Length; i++)
{
Type type = GetMemberType(i);
bool store = true;
locals[i] = new Compiler.Local(ctx, type);
if (!ExpectedType.IsValueType)
{
// value-types always read the old value
if (type.IsValueType)
{
switch (Helpers.GetTypeCode(type))
{
case ProtoTypeCode.Boolean:
case ProtoTypeCode.Byte:
case ProtoTypeCode.Int16:
case ProtoTypeCode.Int32:
case ProtoTypeCode.SByte:
case ProtoTypeCode.UInt16:
case ProtoTypeCode.UInt32:
ctx.LoadValue(0);
break;
case ProtoTypeCode.Int64:
case ProtoTypeCode.UInt64:
ctx.LoadValue(0L);
break;
case ProtoTypeCode.Single:
ctx.LoadValue(0.0F);
break;
case ProtoTypeCode.Double:
ctx.LoadValue(0.0D);
break;
case ProtoTypeCode.Decimal:
ctx.LoadValue(0M);
break;
case ProtoTypeCode.Guid:
ctx.LoadValue(Guid.Empty);
break;
default:
ctx.LoadAddress(locals[i], type);
ctx.EmitCtor(type);
store = false;
break;
}
}
else
{
ctx.LoadNullRef();
}
if (store)
{
ctx.StoreValue(locals[i]);
}
}
}
Compiler.CodeLabel skipOld = ExpectedType.IsValueType
? new Compiler.CodeLabel()
: ctx.DefineLabel();
if (!ExpectedType.IsValueType)
{
ctx.LoadAddress(objValue, ExpectedType);
ctx.BranchIfFalse(skipOld, false);
}
for (int i = 0; i < _members.Length; i++)
{
ctx.LoadAddress(objValue, ExpectedType);
switch (_members[i].Member.MemberType)
{
case MemberTypes.Field:
ctx.LoadValue((FieldInfo)_members[i].Member);
break;
case MemberTypes.Property:
ctx.LoadValue((PropertyInfo)_members[i].Member);
break;
}
ctx.StoreValue(locals[i]);
}
if (!ExpectedType.IsValueType)
{
ctx.MarkLabel(skipOld);
}
using (Compiler.Local fieldNumber = new Compiler.Local(ctx, ctx.MapType(typeof(int))))
{
Compiler.CodeLabel @continue = ctx.DefineLabel(),
processField = ctx.DefineLabel(),
notRecognised = ctx.DefineLabel();
ctx.Branch(@continue, false);
Compiler.CodeLabel[] handlers = new Compiler.CodeLabel[_members.Length];
for (int i = 0; i < _members.Length; i++)
{
handlers[i] = ctx.DefineLabel();
}
ctx.MarkLabel(processField);
ctx.LoadValue(fieldNumber);
ctx.LoadValue(1);
ctx.Subtract(); // jump-table is zero-based
ctx.Switch(handlers);
// and the default:
ctx.Branch(notRecognised, false);
for (int i = 0; i < handlers.Length; i++)
{
ctx.MarkLabel(handlers[i]);
IProtoSerializer tail = _tails[i];
Compiler.Local oldValIfNeeded = tail.RequiresOldValue ? locals[i] : null;
ctx.ReadNullCheckedTail(locals[i].Type, tail, oldValIfNeeded);
if (tail.EmitReadReturnsValue)
{
if (locals[i].Type.IsValueType)
{
ctx.StoreValue(locals[i]);
}
else
{
Compiler.CodeLabel hasValue = ctx.DefineLabel(), allDone = ctx.DefineLabel();
ctx.CopyValue();
ctx.BranchIfTrue(hasValue, true); // interpret null as "don't assign"
ctx.DiscardValue();
ctx.Branch(allDone, true);
ctx.MarkLabel(hasValue);
ctx.StoreValue(locals[i]);
ctx.MarkLabel(allDone);
}
}
ctx.Branch(@continue, false);
}
ctx.MarkLabel(notRecognised);
ctx.LoadReaderWriter();
ctx.EmitCall(ctx.MapType(typeof(ProtoReader)).GetMethod("SkipField"));
ctx.MarkLabel(@continue);
ctx.EmitBasicRead("ReadFieldHeader", ctx.MapType(typeof(int)));
ctx.CopyValue();
ctx.StoreValue(fieldNumber);
ctx.LoadValue(0);
ctx.BranchIfGreater(processField, false);
}
g.Reader.EndSubItem(token);
for (int i = 0; i < locals.Length; i++)
{
ctx.LoadValue(locals[i]);
}
ctx.EmitCtor(_ctor);
ctx.StoreValue(objValue);
ctx.LoadValue(objValue);
ctx.CastToObject(ctx.MapType(_ctor.DeclaringType));
ctx.StoreValue(refLocalToNoteObject);
ctx.LoadValue(reservedTrap);
ctx.LoadAddress(refLocalToNoteObject, refLocalToNoteObject.Type);
ctx.EmitCallNoteReservedTrappedObject();
if (EmitReadReturnsValue)
{
ctx.LoadValue(objValue);
}
}
finally
{
for (int i = 0; i < locals.Length; i++)
{
if (!locals[i].IsNullRef())
{
locals[i].Dispose(); // release for re-use
}
}
}
}
}
}