internal void WriteNullCheckedTail(Type type, IProtoSerializer tail, Local valueFrom) { if (type.IsValueType) { if (Helpers.GetUnderlyingType(type) == null) { tail.EmitWrite(this, valueFrom); return; } using (Local local = this.GetLocalWithValue(type, valueFrom)) { this.LoadAddress(local, type); this.LoadValue(type.GetProperty("HasValue")); CodeLabel label = this.DefineLabel(); this.BranchIfFalse(label, false); this.LoadAddress(local, type); this.EmitCall(type.GetMethod("GetValueOrDefault", Helpers.EmptyTypes)); tail.EmitWrite(this, null); this.MarkLabel(label); return; } } this.LoadValue(valueFrom); this.CopyValue(); CodeLabel label2 = this.DefineLabel(); CodeLabel label3 = this.DefineLabel(); this.BranchIfTrue(label2, true); this.DiscardValue(); this.Branch(label3, false); this.MarkLabel(label2); tail.EmitWrite(this, null); this.MarkLabel(label3); }
} // updates field directly #if FEAT_COMPILER void IProtoSerializer.EmitWrite(Compiler.CompilerContext ctx, Compiler.Local valueFrom) { Type expected = ExpectedType; using (Compiler.Local loc = ctx.GetLocalWithValue(expected, valueFrom)) { // pre-callbacks EmitCallbackIfNeeded(ctx, loc, TypeModel.CallbackType.BeforeSerialize); Compiler.CodeLabel startFields = ctx.DefineLabel(); // inheritance if (CanHaveInheritance) { for (int i = 0; i < serializers.Length; i++) { IProtoSerializer ser = serializers[i]; Type serType = ser.ExpectedType; if (serType != forType) { Compiler.CodeLabel ifMatch = ctx.DefineLabel(), nextTest = ctx.DefineLabel(); ctx.LoadValue(loc); ctx.TryCast(serType); ctx.CopyValue(); ctx.BranchIfTrue(ifMatch, true); ctx.DiscardValue(); ctx.Branch(nextTest, true); ctx.MarkLabel(ifMatch); ser.EmitWrite(ctx, null); ctx.Branch(startFields, false); ctx.MarkLabel(nextTest); } } if (constructType != null && constructType != forType) { using (Compiler.Local actualType = new Compiler.Local(ctx, ctx.MapType(typeof(System.Type)))) { // would have jumped to "fields" if an expected sub-type, so two options: // a: *exactly* that type, b: an *unexpected* type ctx.LoadValue(loc); ctx.EmitCall(ctx.MapType(typeof(object)).GetMethod("GetType")); ctx.CopyValue(); ctx.StoreValue(actualType); ctx.LoadValue(forType); ctx.BranchIfEqual(startFields, true); ctx.LoadValue(actualType); ctx.LoadValue(constructType); ctx.BranchIfEqual(startFields, true); } } else { // would have jumped to "fields" if an expected sub-type, so two options: // a: *exactly* that type, b: an *unexpected* type ctx.LoadValue(loc); ctx.EmitCall(ctx.MapType(typeof(object)).GetMethod("GetType")); ctx.LoadValue(forType); ctx.BranchIfEqual(startFields, true); } // unexpected, then... note that this *might* be a proxy, which // is handled by ThrowUnexpectedSubtype ctx.LoadValue(forType); ctx.LoadValue(loc); ctx.EmitCall(ctx.MapType(typeof(object)).GetMethod("GetType")); ctx.EmitCall(ctx.MapType(typeof(TypeModel)).GetMethod("ThrowUnexpectedSubtype", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static)); } // fields ctx.MarkLabel(startFields); for (int i = 0; i < serializers.Length; i++) { IProtoSerializer ser = serializers[i]; if (ser.ExpectedType == forType) { ser.EmitWrite(ctx, loc); } } // extension data if (isExtensible) { ctx.LoadValue(loc); ctx.LoadReaderWriter(); ctx.EmitCall(ctx.MapType(typeof(ProtoWriter)).GetMethod("AppendExtensionData")); } // post-callbacks EmitCallbackIfNeeded(ctx, loc, TypeModel.CallbackType.AfterSerialize); } }
internal void WriteNullCheckedTail(Type type, IProtoSerializer tail, Compiler.Local valueFrom) { if (type.IsValueType) { Type underlyingType = null; #if !FX11 underlyingType = Helpers.GetUnderlyingType(type); #endif if (underlyingType == null) { // not a nullable T; can invoke directly tail.EmitWrite(this, valueFrom); } else { // nullable T; check HasValue using (Compiler.Local valOrNull = GetLocalWithValue(type, valueFrom)) { LoadAddress(valOrNull, type); LoadValue(type.GetProperty("HasValue")); CodeLabel @end = DefineLabel(); BranchIfFalse(@end, false); LoadAddress(valOrNull, type); EmitCall(type.GetMethod("GetValueOrDefault", Helpers.EmptyTypes)); tail.EmitWrite(this, null); MarkLabel(@end); } } } else { // ref-type; do a null-check LoadValue(valueFrom); CopyValue(); CodeLabel hasVal = DefineLabel(), @end = DefineLabel(); BranchIfTrue(hasVal, true); DiscardValue(); Branch(@end, false); MarkLabel(hasVal); tail.EmitWrite(this, null); MarkLabel(@end); } }
void IProtoSerializer.EmitWrite(CompilerContext ctx, Local valueFrom) { Type expectedType = this.ExpectedType; using (Local local = ctx.GetLocalWithValue(expectedType, valueFrom)) { this.EmitCallbackIfNeeded(ctx, local, TypeModel.CallbackType.BeforeSerialize); CodeLabel label = ctx.DefineLabel(); if (!this.CanHaveInheritance) { goto Label_0206; } for (int i = 0; i < this.serializers.Length; i++) { IProtoSerializer serializer = this.serializers[i]; Type type = serializer.ExpectedType; if (type != this.forType) { CodeLabel label2 = ctx.DefineLabel(); CodeLabel label3 = ctx.DefineLabel(); ctx.LoadValue(local); ctx.TryCast(type); ctx.CopyValue(); ctx.BranchIfTrue(label2, true); ctx.DiscardValue(); ctx.Branch(label3, true); ctx.MarkLabel(label2); serializer.EmitWrite(ctx, null); ctx.Branch(label, false); ctx.MarkLabel(label3); } } if ((this.constructType != null) && (this.constructType != this.forType)) { using (Local local2 = new Local(ctx, ctx.MapType(typeof(Type)))) { ctx.LoadValue(local); ctx.EmitCall(ctx.MapType(typeof(object)).GetMethod("GetType")); ctx.CopyValue(); ctx.StoreValue(local2); ctx.LoadValue(this.forType); ctx.BranchIfEqual(label, true); ctx.LoadValue(local2); ctx.LoadValue(this.constructType); ctx.BranchIfEqual(label, true); goto Label_01B1; } } ctx.LoadValue(local); ctx.EmitCall(ctx.MapType(typeof(object)).GetMethod("GetType")); ctx.LoadValue(this.forType); ctx.BranchIfEqual(label, true); Label_01B1: ctx.LoadValue(this.forType); ctx.LoadValue(local); ctx.EmitCall(ctx.MapType(typeof(object)).GetMethod("GetType")); ctx.EmitCall(ctx.MapType(typeof(TypeModel)).GetMethod("ThrowUnexpectedSubtype", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static)); Label_0206: ctx.MarkLabel(label); for (int j = 0; j < this.serializers.Length; j++) { IProtoSerializer serializer2 = this.serializers[j]; if (serializer2.ExpectedType == this.forType) { serializer2.EmitWrite(ctx, local); } } if (this.isExtensible) { ctx.LoadValue(local); ctx.LoadReaderWriter(); ctx.EmitCall(ctx.MapType(typeof(ProtoWriter)).GetMethod("AppendExtensionData")); } this.EmitCallbackIfNeeded(ctx, local, TypeModel.CallbackType.AfterSerialize); } }
void ProtoBuf.Serializers.IProtoSerializer.EmitWrite(CompilerContext ctx, Local valueFrom) { using (Local localWithValue = ctx.GetLocalWithValue(this.ExpectedType, valueFrom)) { this.EmitCallbackIfNeeded(ctx, localWithValue, TypeModel.CallbackType.BeforeSerialize); CodeLabel codeLabel = ctx.DefineLabel(); if (this.CanHaveInheritance) { for (int i = 0; i < (int)this.serializers.Length; i++) { IProtoSerializer protoSerializer = this.serializers[i]; Type expectedType = protoSerializer.ExpectedType; if (expectedType != this.forType) { CodeLabel codeLabel1 = ctx.DefineLabel(); CodeLabel codeLabel2 = ctx.DefineLabel(); ctx.LoadValue(localWithValue); ctx.TryCast(expectedType); ctx.CopyValue(); ctx.BranchIfTrue(codeLabel1, true); ctx.DiscardValue(); ctx.Branch(codeLabel2, true); ctx.MarkLabel(codeLabel1); protoSerializer.EmitWrite(ctx, null); ctx.Branch(codeLabel, false); ctx.MarkLabel(codeLabel2); } } if (this.constructType == null || this.constructType == this.forType) { ctx.LoadValue(localWithValue); ctx.EmitCall(ctx.MapType(typeof(object)).GetMethod("GetType")); ctx.LoadValue(this.forType); ctx.BranchIfEqual(codeLabel, true); } else { using (Local local = new Local(ctx, ctx.MapType(typeof(Type)))) { ctx.LoadValue(localWithValue); ctx.EmitCall(ctx.MapType(typeof(object)).GetMethod("GetType")); ctx.CopyValue(); ctx.StoreValue(local); ctx.LoadValue(this.forType); ctx.BranchIfEqual(codeLabel, true); ctx.LoadValue(local); ctx.LoadValue(this.constructType); ctx.BranchIfEqual(codeLabel, true); } } ctx.LoadValue(this.forType); ctx.LoadValue(localWithValue); ctx.EmitCall(ctx.MapType(typeof(object)).GetMethod("GetType")); ctx.EmitCall(ctx.MapType(typeof(TypeModel)).GetMethod("ThrowUnexpectedSubtype", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)); } ctx.MarkLabel(codeLabel); for (int j = 0; j < (int)this.serializers.Length; j++) { IProtoSerializer protoSerializer1 = this.serializers[j]; if (protoSerializer1.ExpectedType == this.forType) { protoSerializer1.EmitWrite(ctx, localWithValue); } } if (this.isExtensible) { ctx.LoadValue(localWithValue); ctx.LoadReaderWriter(); ctx.EmitCall(ctx.MapType(typeof(ProtoWriter)).GetMethod("AppendExtensionData")); } this.EmitCallbackIfNeeded(ctx, localWithValue, TypeModel.CallbackType.AfterSerialize); } }