public bool FreeContent(IILGen ilGenerator, Action<IILGen> pushReaderOrCtx) { var needsFreeContent = false; var localCount = ilGenerator.DeclareLocal(typeof(uint)); var finish = ilGenerator.DefineLabel(); var next = ilGenerator.DefineLabel(); ilGenerator .Do(pushReaderOrCtx) .Callvirt(() => ((IReaderCtx)null).SkipObject()) .Brfalse(finish) .Do(Extensions.PushReaderFromCtx(pushReaderOrCtx)) .Callvirt(() => ((AbstractBufferedReader)null).ReadVUInt32()) .Stloc(localCount) .Mark(next) .Ldloc(localCount) .Brfalse(finish) .Ldloc(localCount) .LdcI4(1) .Sub() .ConvU4() .Stloc(localCount) .GenerateFreeContent(_keysHandler, pushReaderOrCtx, ref needsFreeContent) .GenerateFreeContent(_valuesHandler, pushReaderOrCtx, ref needsFreeContent) .Br(next) .Mark(finish); return needsFreeContent; }
public static void GenerateLoadEx(this ITypeDescriptor descriptor, IILGen ilGenerator, Action<IILGen> pushReader, Action<IILGen> pushCtx, Action<IILGen> pushDescriptor, Type asType, ITypeConvertorGenerator convertorGenerator) { if (descriptor.StoredInline) { if (descriptor.LoadNeedsHelpWithConversion && asType!=typeof(object)) { var origType = descriptor.GetPreferedType(); descriptor.GenerateLoad(ilGenerator, pushReader, pushCtx, pushDescriptor, origType); if (origType != asType) { var conv = convertorGenerator.GenerateConversion(origType, asType); if (conv == null) throw new BTDBException("Don't know how to convert " + descriptor.Name + " from " + origType.ToSimpleName() + " to " + asType.ToSimpleName()); conv(ilGenerator); } } else { descriptor.GenerateLoad(ilGenerator, pushReader, pushCtx, pushDescriptor, asType); } } else { ilGenerator .Do(pushCtx) .Callvirt(() => default(ITypeBinaryDeserializerContext).LoadObject()); if (asType != typeof(object)) ilGenerator.Castclass(asType); } }
internal void ReplayTo(IILGen target) { foreach (var inst in _instructions) { inst.ReplayTo(target); } }
public void Load(IILGen ilGenerator, Action<IILGen> pushReaderOrCtx) { ilGenerator .Do(pushReaderOrCtx) .Callvirt(() => default(IReaderCtx).ReadNativeObject()); var type = HandledType(); ilGenerator.Do(_service.TypeConvertorGenerator.GenerateConversion(typeof(object), type)); }
public void Save(IILGen ilGenerator, Action<IILGen> pushWriterOrCtx, Action<IILGen> pushValue) { ilGenerator .Do(pushWriterOrCtx) .Do(pushValue) .Do(_service.TypeConvertorGenerator.GenerateConversion(HandledType(), typeof(object))) .Callvirt(() => default(IWriterCtx).WriteNativeObject(null)); }
public void GenerateSave(IILGen ilGenerator, Action<IILGen> pushWriter, Action<IILGen> pushCtx, Action<IILGen> pushValue, Type valueType) { pushWriter(ilGenerator); pushValue(ilGenerator); if (valueType==typeof(byte[])) ilGenerator.Call(() => default(AbstractBufferedWriter).WriteByteArray(null)); else if (valueType==typeof(ByteBuffer)) ilGenerator.Call(() => default(AbstractBufferedWriter).WriteByteArray(ByteBuffer.NewEmpty())); else throw new ArgumentOutOfRangeException(nameof(valueType)); }
public bool FreeContent(IILGen ilGenerator, Action<IILGen> pushReaderOrCtx) { var tableInfo = ((ObjectDB) _objectDB).TablesInfo.FindByType(HandledType()); //decides upon current version (null for object types never stored in DB) var needsContent = tableInfo == null || tableInfo.GetFreeContent(tableInfo.ClientTypeVersion).Item1; ilGenerator .Do(pushReaderOrCtx) .Callvirt(() => default(IReaderCtx).FreeContentInNativeObject()); return needsContent; }
public static void GenerateSkipEx(this ITypeDescriptor descriptor, IILGen ilGenerator, Action<IILGen> pushReader, Action<IILGen> pushCtx) { if (descriptor.StoredInline) { descriptor.GenerateSkip(ilGenerator, pushReader, pushCtx); } else { ilGenerator .Do(pushCtx) .Callvirt(() => default(ITypeBinaryDeserializerContext).SkipObject()); } }
public static void GenerateSaveEx(this ITypeDescriptor descriptor, IILGen ilGenerator, Action<IILGen> pushWriter, Action<IILGen> pushCtx, Action<IILGen> pushSubValue, Type subValueType) { if (descriptor.StoredInline) { descriptor.GenerateSave(ilGenerator, pushWriter, pushCtx, pushSubValue, subValueType); } else { ilGenerator .Do(pushCtx) .Do(pushSubValue) .Callvirt(() => default(ITypeBinarySerializerContext).StoreObject(null)); } }
public void Load(IILGen ilGenerator, Action<IILGen> pushReaderOrCtx) { var localCount = ilGenerator.DeclareLocal(typeof(uint)); var localResultOfObject = ilGenerator.DeclareLocal(typeof(object)); var localResult = ilGenerator.DeclareLocal(HandledType()); var loadSkipped = ilGenerator.DefineLabel(); var finish = ilGenerator.DefineLabel(); var readfinish = ilGenerator.DefineLabel(); var next = ilGenerator.DefineLabel(); var genericArguments = _type.GetGenericArguments(); object fake; ilGenerator .Do(pushReaderOrCtx) .Ldloca(localResultOfObject) .Callvirt(() => default(IReaderCtx).ReadObject(out fake)) .Brfalse(loadSkipped) .Do(Extensions.PushReaderFromCtx(pushReaderOrCtx)) .Callvirt(() => default(AbstractBufferedReader).ReadVUInt32()) .Stloc(localCount) .Ldloc(localCount) .Newobj(typeof(Dictionary<,>).MakeGenericType(genericArguments).GetConstructor(new[] { typeof(int) })) .Stloc(localResult) .Do(pushReaderOrCtx) .Ldloc(localResult) .Castclass(typeof(object)) .Callvirt(() => default(IReaderCtx).RegisterObject(null)) .Mark(next) .Ldloc(localCount) .Brfalse(readfinish) .Ldloc(localCount) .LdcI4(1) .Sub() .ConvU4() .Stloc(localCount) .Ldloc(localResult) .GenerateLoad(_keysHandler, genericArguments[0], pushReaderOrCtx, _typeConvertorGenerator) .GenerateLoad(_valuesHandler, genericArguments[1], pushReaderOrCtx, _typeConvertorGenerator) .Callvirt(_type.GetMethod("Add")) .Br(next) .Mark(readfinish) .Do(pushReaderOrCtx) .Callvirt(() => default(IReaderCtx).ReadObjectDone()) .Br(finish) .Mark(loadSkipped) .Ldloc(localResultOfObject) .Isinst(_type) .Stloc(localResult) .Mark(finish) .Ldloc(localResult); }
public static void GenerateLoadEx(this ITypeDescriptor descriptor, IILGen ilGenerator, Action<IILGen> pushReader, Action<IILGen> pushCtx, Action<IILGen> pushDescriptor, Type asType) { if (descriptor.StoredInline) { descriptor.GenerateLoad(ilGenerator, pushReader, pushCtx, pushDescriptor, asType); } else { ilGenerator .Do(pushCtx) .Callvirt(() => default(ITypeBinaryDeserializerContext).LoadObject()); if (asType != typeof(object)) ilGenerator.Castclass(asType); } }
public void Load(IILGen ilGenerator, Action<IILGen> pushReaderOrCtx) { pushReaderOrCtx(ilGenerator); Type typeRead; if (_signed) { ilGenerator.Call(() => default(AbstractBufferedReader).ReadVInt64()); typeRead = typeof(long); } else { ilGenerator.Call(() => default(AbstractBufferedReader).ReadVUInt64()); typeRead = typeof(ulong); } new DefaultTypeConvertorGenerator().GenerateConversion(typeRead, _enumType.GetEnumUnderlyingType())(ilGenerator); }
public void GenerateLoad(IILGen ilGenerator, Action<IILGen> pushReader, Action<IILGen> pushCtx, Action<IILGen> pushDescriptor, Type targetType) { pushReader(ilGenerator); ilGenerator.Call(() => default(AbstractBufferedReader).ReadByteArray()); if (targetType == typeof (ByteBuffer)) { ilGenerator.Call(() => ByteBuffer.NewAsync(null)); return; } if (targetType != typeof (object)) { if (targetType!=typeof(byte[])) throw new ArgumentOutOfRangeException(nameof(targetType)); return; } ilGenerator.Castclass(typeof(object)); }
public void GenerateLoad(IILGen ilGenerator, Action<IILGen> pushReader, Action<IILGen> pushCtx, Action<IILGen> pushDescriptor, Type targetType) { pushReader(ilGenerator); ilGenerator.Call(_loader); if (targetType != typeof(object)) { if (targetType != GetPreferedType()) throw new ArgumentOutOfRangeException(nameof(targetType)); return; } if (GetPreferedType().IsValueType) { ilGenerator.Box(GetPreferedType()); } else { ilGenerator.Castclass(typeof(object)); } }
public static IILGen BrtrueS(this IILGen il, IILLabel targetLabel) { il.Emit(OpCodes.Brtrue_S, targetLabel); return(il); }
public static IILGen BleUnS(this IILGen il, IILLabel targetLabel) { il.Emit(OpCodes.Ble_Un_S, targetLabel); return(il); }
public static IILGen Ldloca(this IILGen il, IILLocal localBuilder) { il.Emit(OpCodes.Ldloca, localBuilder); return(il); }
public static IILGen Stsfld(this IILGen il, IILField fieldInfo) { il.Emit(OpCodes.Stsfld, fieldInfo); return(il); }
public static IILGen Ldflda(this IILGen il, IILField fieldInfo) { il.Emit(OpCodes.Ldflda, fieldInfo); return(il); }
public void ReplayTo(IILGen target) { target.Ldftn(_method); }
public static IILGen Add(this IILGen il) { il.Emit(OpCodes.Add); return(il); }
public static IILGen StelemRef(this IILGen il) { il.Emit(OpCodes.Stelem_Ref); return(il); }
public static IILGen Tail(this IILGen il) { il.Emit(OpCodes.Tailcall); return(il); }
public static IILGen ConvR8(this IILGen il) { il.Emit(OpCodes.Conv_R8); return(il); }
public static IILGen ConvI4(this IILGen il) { il.Emit(OpCodes.Conv_I4); return(il); }
public static IILGen ConvU2(this IILGen il) { il.Emit(OpCodes.Conv_U2); return(il); }
public static IILGen Isinst(this IILGen il, Type asType) { il.Emit(OpCodes.Isinst, asType); return(il); }
public static IILGen Sub(this IILGen il) { il.Emit(OpCodes.Sub); return(il); }
public void ReplayTo(IILGen target) { target.Mark(((ILLabel)_label).Label); }
public static IILGen Mul(this IILGen il) { il.Emit(OpCodes.Mul); return(il); }
public static IILGen Do(this IILGen il, Action <IILGen> action) { action(il); return(il); }
public static IILGen Div(this IILGen il) { il.Emit(OpCodes.Div); return(il); }
public static IILGen Ldsfld(this IILGen il, FieldInfo fieldInfo) { il.Emit(OpCodes.Ldsfld, fieldInfo); return(il); }
public void GenerateSkip(IILGen ilGenerator, Action<IILGen> pushReader, Action<IILGen> pushCtx) { var localCount = ilGenerator.DeclareLocal(typeof(uint)); var skipFinished = ilGenerator.DefineLabel(); var next = ilGenerator.DefineLabel(); ilGenerator .Do(pushReader) .Callvirt(() => default(AbstractBufferedReader).ReadVUInt32()) .Stloc(localCount) .Ldloc(localCount) .Brfalse(skipFinished) .Mark(next) .Ldloc(localCount) .LdcI4(1) .Sub() .Stloc(localCount) .Ldloc(localCount) .Brfalse(skipFinished); _keyDescriptor.GenerateSkipEx(ilGenerator, pushReader, pushCtx); _valueDescriptor.GenerateSkipEx(ilGenerator, pushReader, pushCtx); ilGenerator .Br(next) .Mark(skipFinished); }
public static IILGen Stloc(this IILGen il, IILLocal localBuilder) { il.Emit(OpCodes.Stloc, localBuilder); return(il); }
public void ReplayTo(IILGen target) { target.Catch(_exceptionType); }
public static IILGen Constrained(this IILGen il, Type type) { il.Emit(OpCodes.Constrained, type); return(il); }
public void ReplayTo(IILGen target) { target.Emit(_opCode, _constructorInfo); }
public static IILGen Brfalse(this IILGen il, IILLabel targetLabel) { il.Emit(OpCodes.Brfalse, targetLabel); return(il); }
public void ReplayTo(IILGen target) { target.Emit(_opCode, _methodInfo); }
public void ReplayTo(IILGen target) { target.Emit(_opCode, _param); }
public void ReplayTo(IILGen target) { Label = target.DefineLabel(_name); }
public static IILGen Dup(this IILGen il) { il.Emit(OpCodes.Dup); return(il); }
public static IILGen Castclass(this IILGen il, Type toType) { il.Emit(OpCodes.Castclass, toType); return(il); }
public void GenerateTypeIterator(IILGen ilGenerator, Action<IILGen> pushObj, Action<IILGen> pushCtx, Type type) { var finish = ilGenerator.DefineLabel(); var next = ilGenerator.DefineLabel(); var keyType = _owner._typeSerializers.LoadAsType(_owner._keyDescriptor); var valueType = _owner._typeSerializers.LoadAsType(_owner._valueDescriptor); if (_owner._type == null) _owner._type = type; var isDict = _owner._type != null && _owner._type.GetGenericTypeDefinition() == typeof(Dictionary<,>); var typeAsIDictionary = isDict ? _owner._type : typeof(IDictionary<,>).MakeGenericType(keyType, valueType); var getEnumeratorMethod = isDict ? typeAsIDictionary.GetMethods() .Single( m => m.Name == "GetEnumerator" && m.ReturnType.IsValueType && m.GetParameters().Length == 0) : typeAsIDictionary.GetInterface("IEnumerable`1").GetMethod("GetEnumerator"); var typeAsIEnumerator = getEnumeratorMethod.ReturnType; var currentGetter = typeAsIEnumerator.GetProperty("Current").GetGetMethod(); var typeKeyValuePair = currentGetter.ReturnType; var localEnumerator = ilGenerator.DeclareLocal(typeAsIEnumerator); var localPair = ilGenerator.DeclareLocal(typeKeyValuePair); ilGenerator .Do(pushObj) .Castclass(typeAsIDictionary) .Callvirt(getEnumeratorMethod) .Stloc(localEnumerator) .Try() .Mark(next) .Do(il => { if (isDict) { il .Ldloca(localEnumerator) .Call(typeAsIEnumerator.GetMethod("MoveNext")); } else { il .Ldloc(localEnumerator) .Callvirt(() => default(IEnumerator).MoveNext()); } }) .Brfalse(finish) .Do(il => { if (isDict) { il .Ldloca(localEnumerator) .Call(currentGetter); } else { il .Ldloc(localEnumerator) .Callvirt(currentGetter); } }) .Stloc(localPair); if (!_owner._keyDescriptor.Sealed) { ilGenerator .Do(pushCtx) .Ldloca(localPair) .Call(typeKeyValuePair.GetProperty("Key").GetGetMethod()) .Callvirt(() => default(IDescriptorSerializerLiteContext).StoreNewDescriptors(null)); } if (!_owner._valueDescriptor.Sealed) { ilGenerator .Do(pushCtx) .Ldloca(localPair) .Call(typeKeyValuePair.GetProperty("Value").GetGetMethod()) .Callvirt(() => default(IDescriptorSerializerLiteContext).StoreNewDescriptors(null)); } ilGenerator .Br(next) .Mark(finish) .Finally() .Do(il => { if (isDict) { il .Ldloca(localEnumerator) .Constrained(typeAsIEnumerator); } else { il.Ldloc(localEnumerator); } }) .Callvirt(() => default(IDisposable).Dispose()) .EndTry(); }
public static IILGen Ldtoken(this IILGen il, Type type) { il.Emit(OpCodes.Ldtoken, type); return(il); }
public void ReplayTo(IILGen target) { target.Comment(_text); }
public static IILGen Callvirt(this IILGen il, Expression <Action> expression) { var methodInfo = (expression.Body as MethodCallExpression).Method; return(il.Callvirt(methodInfo)); }
public void ReplayTo(IILGen target) { target.Emit(_opCode, ((ILLocal)_ilLocal).Local); }
public static IILGen Newobj(this IILGen il, Expression <Action> expression) { var constructorInfo = (expression.Body as NewExpression).Constructor; return(il.Newobj(constructorInfo)); }
public void ReplayTo(IILGen target) { target.Emit(_opCode, _type); }
public static IILGen Ldfld <T>(this IILGen il, Expression <Func <T> > expression) { return(il.Ldfld((FieldInfo)(expression.Body as MemberExpression).Member)); }
public void ReplayTo(IILGen target) { target.Finally(); }
public static IILGen Newarr(this IILGen il, Type arrayMemberType) { il.Emit(OpCodes.Newarr, arrayMemberType); return(il); }
public void ReplayTo(IILGen target) { Local = target.DeclareLocal(_type, _name, _pinned); Debug.Assert(Local.Index == Index); }
public static IILGen Box(this IILGen il, Type boxedType) { il.Emit(OpCodes.Box, boxedType); return(il); }
public void ReplayTo(IILGen target) { target.Ldstr(_str); }
public static IILGen UnboxAny(this IILGen il, Type anyType) { il.Emit(OpCodes.Unbox_Any, anyType); return(il); }
public void ReplayTo(IILGen target) { target.Try(); }
public static IILGen Break(this IILGen il) { il.Emit(OpCodes.Break); return(il); }