Ejemplo n.º 1
0
 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;
 }
Ejemplo n.º 2
0
 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);
     }
 }
Ejemplo n.º 3
0
 internal void ReplayTo(IILGen target)
 {
     foreach (var inst in _instructions)
     {
         inst.ReplayTo(target);
     }
 }
Ejemplo n.º 4
0
 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));
 }
Ejemplo n.º 5
0
 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));
 }
Ejemplo n.º 6
0
 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));
 }
Ejemplo n.º 7
0
 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;
 }
Ejemplo n.º 8
0
 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());
     }
 }
Ejemplo n.º 9
0
 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));
     }
 }
Ejemplo n.º 10
0
 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);
 }
Ejemplo n.º 11
0
 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);
     }
 }
Ejemplo n.º 12
0
 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);
 }
Ejemplo n.º 13
0
 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));
 }
Ejemplo n.º 14
0
 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));
     }
 }
Ejemplo n.º 15
0
 public static IILGen BrtrueS(this IILGen il, IILLabel targetLabel)
 {
     il.Emit(OpCodes.Brtrue_S, targetLabel);
     return(il);
 }
Ejemplo n.º 16
0
 public static IILGen BleUnS(this IILGen il, IILLabel targetLabel)
 {
     il.Emit(OpCodes.Ble_Un_S, targetLabel);
     return(il);
 }
Ejemplo n.º 17
0
 public static IILGen Ldloca(this IILGen il, IILLocal localBuilder)
 {
     il.Emit(OpCodes.Ldloca, localBuilder);
     return(il);
 }
Ejemplo n.º 18
0
 public static IILGen Stsfld(this IILGen il, IILField fieldInfo)
 {
     il.Emit(OpCodes.Stsfld, fieldInfo);
     return(il);
 }
Ejemplo n.º 19
0
 public static IILGen Ldflda(this IILGen il, IILField fieldInfo)
 {
     il.Emit(OpCodes.Ldflda, fieldInfo);
     return(il);
 }
Ejemplo n.º 20
0
 public void ReplayTo(IILGen target)
 {
     target.Ldftn(_method);
 }
Ejemplo n.º 21
0
 public static IILGen Add(this IILGen il)
 {
     il.Emit(OpCodes.Add);
     return(il);
 }
Ejemplo n.º 22
0
 public static IILGen StelemRef(this IILGen il)
 {
     il.Emit(OpCodes.Stelem_Ref);
     return(il);
 }
Ejemplo n.º 23
0
 public static IILGen Tail(this IILGen il)
 {
     il.Emit(OpCodes.Tailcall);
     return(il);
 }
Ejemplo n.º 24
0
 public static IILGen ConvR8(this IILGen il)
 {
     il.Emit(OpCodes.Conv_R8);
     return(il);
 }
Ejemplo n.º 25
0
 public static IILGen ConvI4(this IILGen il)
 {
     il.Emit(OpCodes.Conv_I4);
     return(il);
 }
Ejemplo n.º 26
0
 public static IILGen ConvU2(this IILGen il)
 {
     il.Emit(OpCodes.Conv_U2);
     return(il);
 }
Ejemplo n.º 27
0
 public static IILGen Isinst(this IILGen il, Type asType)
 {
     il.Emit(OpCodes.Isinst, asType);
     return(il);
 }
Ejemplo n.º 28
0
 public static IILGen Sub(this IILGen il)
 {
     il.Emit(OpCodes.Sub);
     return(il);
 }
Ejemplo n.º 29
0
 public void ReplayTo(IILGen target)
 {
     target.Mark(((ILLabel)_label).Label);
 }
Ejemplo n.º 30
0
 public static IILGen Mul(this IILGen il)
 {
     il.Emit(OpCodes.Mul);
     return(il);
 }
Ejemplo n.º 31
0
 public static IILGen Do(this IILGen il, Action <IILGen> action)
 {
     action(il);
     return(il);
 }
Ejemplo n.º 32
0
 public static IILGen Div(this IILGen il)
 {
     il.Emit(OpCodes.Div);
     return(il);
 }
Ejemplo n.º 33
0
 public static IILGen Ldsfld(this IILGen il, FieldInfo fieldInfo)
 {
     il.Emit(OpCodes.Ldsfld, fieldInfo);
     return(il);
 }
Ejemplo n.º 34
0
 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);
 }
Ejemplo n.º 35
0
 public static IILGen Stloc(this IILGen il, IILLocal localBuilder)
 {
     il.Emit(OpCodes.Stloc, localBuilder);
     return(il);
 }
Ejemplo n.º 36
0
 public void ReplayTo(IILGen target)
 {
     target.Catch(_exceptionType);
 }
Ejemplo n.º 37
0
 public static IILGen Constrained(this IILGen il, Type type)
 {
     il.Emit(OpCodes.Constrained, type);
     return(il);
 }
Ejemplo n.º 38
0
 public void ReplayTo(IILGen target)
 {
     target.Emit(_opCode, _constructorInfo);
 }
Ejemplo n.º 39
0
 public static IILGen Brfalse(this IILGen il, IILLabel targetLabel)
 {
     il.Emit(OpCodes.Brfalse, targetLabel);
     return(il);
 }
Ejemplo n.º 40
0
 public void ReplayTo(IILGen target)
 {
     target.Emit(_opCode, _methodInfo);
 }
Ejemplo n.º 41
0
 public void ReplayTo(IILGen target)
 {
     target.Emit(_opCode, _param);
 }
Ejemplo n.º 42
0
 public void ReplayTo(IILGen target)
 {
     Label = target.DefineLabel(_name);
 }
Ejemplo n.º 43
0
 public static IILGen Dup(this IILGen il)
 {
     il.Emit(OpCodes.Dup);
     return(il);
 }
Ejemplo n.º 44
0
 public static IILGen Castclass(this IILGen il, Type toType)
 {
     il.Emit(OpCodes.Castclass, toType);
     return(il);
 }
Ejemplo n.º 45
0
 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();
 }
Ejemplo n.º 46
0
 public static IILGen Ldtoken(this IILGen il, Type type)
 {
     il.Emit(OpCodes.Ldtoken, type);
     return(il);
 }
Ejemplo n.º 47
0
 public void ReplayTo(IILGen target)
 {
     target.Comment(_text);
 }
Ejemplo n.º 48
0
        public static IILGen Callvirt(this IILGen il, Expression <Action> expression)
        {
            var methodInfo = (expression.Body as MethodCallExpression).Method;

            return(il.Callvirt(methodInfo));
        }
Ejemplo n.º 49
0
 public void ReplayTo(IILGen target)
 {
     target.Emit(_opCode, ((ILLocal)_ilLocal).Local);
 }
Ejemplo n.º 50
0
        public static IILGen Newobj(this IILGen il, Expression <Action> expression)
        {
            var constructorInfo = (expression.Body as NewExpression).Constructor;

            return(il.Newobj(constructorInfo));
        }
Ejemplo n.º 51
0
 public void ReplayTo(IILGen target)
 {
     target.Emit(_opCode, _type);
 }
Ejemplo n.º 52
0
 public static IILGen Ldfld <T>(this IILGen il, Expression <Func <T> > expression)
 {
     return(il.Ldfld((FieldInfo)(expression.Body as MemberExpression).Member));
 }
Ejemplo n.º 53
0
 public void ReplayTo(IILGen target)
 {
     target.Finally();
 }
Ejemplo n.º 54
0
 public static IILGen Newarr(this IILGen il, Type arrayMemberType)
 {
     il.Emit(OpCodes.Newarr, arrayMemberType);
     return(il);
 }
Ejemplo n.º 55
0
 public void ReplayTo(IILGen target)
 {
     Local = target.DeclareLocal(_type, _name, _pinned);
     Debug.Assert(Local.Index == Index);
 }
Ejemplo n.º 56
0
 public static IILGen Box(this IILGen il, Type boxedType)
 {
     il.Emit(OpCodes.Box, boxedType);
     return(il);
 }
Ejemplo n.º 57
0
 public void ReplayTo(IILGen target)
 {
     target.Ldstr(_str);
 }
Ejemplo n.º 58
0
 public static IILGen UnboxAny(this IILGen il, Type anyType)
 {
     il.Emit(OpCodes.Unbox_Any, anyType);
     return(il);
 }
Ejemplo n.º 59
0
 public void ReplayTo(IILGen target)
 {
     target.Try();
 }
Ejemplo n.º 60
0
 public static IILGen Break(this IILGen il)
 {
     il.Emit(OpCodes.Break);
     return(il);
 }