Beispiel #1
0
        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);
        }
        public void EmitWrite(Compiler.CompilerContext ctx, Compiler.Local valueFrom)
        {
            using (ctx.StartDebugBlockAuto(this))
            {
                var g = ctx.G;
                using (Compiler.Local value = ctx.GetLocalWithValue(_ctor.DeclaringType, valueFrom))
                    using (Compiler.Local token = ctx.Local(typeof(SubItemToken)))
                    {
                        g.Assign(token, g.WriterFunc.StartSubItem(value, _prefixLength));
                        for (int i = 0; i < _tails.Length; i++)
                        {
                            Type type = GetMemberType(i);
                            ctx.LoadAddress(value, 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.LoadValue(i + 1);
                            ctx.LoadReaderWriter();
                            ctx.EmitCall(ctx.MapType(typeof(ProtoWriter)).GetMethod(nameof(ProtoWriter.WriteFieldHeaderBegin)));
                            ctx.WriteNullCheckedTail(type, _tails[i], null, true);
                        }
                        g.Writer.EndSubItem(token);
                    }
            }
        }
        public void EmitWrite(Compiler.CompilerContext ctx, Compiler.Local valueFrom)

        {
            using (Compiler.Local loc = ctx.GetLocalWithValue(ctor.DeclaringType, valueFrom))

            {
                for (int i = 0; i < tails.Length; i++)

                {
                    Type type = GetMemberType(i);

                    ctx.LoadAddress(loc, ExpectedType);

                    switch (members[i].MemberType)

                    {
                    case MemberTypes.Field:

                        ctx.LoadValue((FieldInfo)members[i]);

                        break;

                    case MemberTypes.Property:

                        ctx.LoadValue((PropertyInfo)members[i]);

                        break;
                    }

                    ctx.WriteNullCheckedTail(type, tails[i], null);
                }
            }
        }
        protected override void EmitWrite(Compiler.CompilerContext ctx, Compiler.Local valueFrom)

        {
            ctx.LoadAddress(valueFrom, ExpectedType);

            ctx.LoadValue(field);

            ctx.WriteNullCheckedTail(field.FieldType, Tail, null);
        }
Beispiel #5
0
 public void EmitWrite(Compiler.CompilerContext ctx, Compiler.Local valueFrom)
 {
     using Compiler.Local loc = ctx.GetLocalWithValue(ctor.DeclaringType, valueFrom);
     for (int i = 0; i < tails.Length; i++)
     {
         Type type = GetMemberType(i);
         ctx.LoadAddress(loc, ExpectedType);
         if (members[i] is FieldInfo fieldInfo)
         {
             ctx.LoadValue(fieldInfo);
         }
         else if (members[i] is PropertyInfo propertyInfo)
         {
             ctx.LoadValue(propertyInfo);
         }
         ctx.WriteNullCheckedTail(type, tails[i], null);
     }
 }
Beispiel #6
0
 protected override void EmitWrite(Compiler.CompilerContext ctx, Compiler.Local valueFrom)
 {
     ctx.LoadAddress(valueFrom, ExpectedType);
     ctx.LoadValue(property);
     ctx.WriteNullCheckedTail(property.PropertyType, Tail, null, overrideType);
 }