void IPartBuilder.GenerateFillPart(GenFillContext context)
        {
            var g = context.Generator;

            g.If(() =>
            {
                g.Load(context.NextIsNull);
                return(BinaryOperator.IsTrue);
            });
            {
                g.Load(context.Member, LoadOptions.ValueAsAddress);
                g.InitializeValue();
            }
            g.Else();
            {
                g.BeginAssign(context.Member);
                {
                    var value = g.DeclareLocal(_innerType);
                    context.InnerFill(_innerBuilder, g.CreateExpression(value));
                    g.BeginNewObject(_ctor);
                    {
                        g.Load(value);
                    }
                    g.EndNewObject();
                }
                g.EndAssign();
            }
            g.EndIf();
        }
Beispiel #2
0
        public void GenerateFillPart(GenFillContext context)
        {
            var g         = context.Generator;
            var primitive = g.CreateExpression(g.DeclareLocal(_targetType));

            context.InnerFill(_innerBuilder, primitive);

            GenerateConvert(g, _fromPrimitiveMethod, primitive, context.Member);
        }
        public void GenerateFillPart(GenFillContext context)
        {
            var g = context.Generator;

            var key   = g.CreateExpression(g.DeclareLocal(_keyType));
            var value = g.CreateExpression(g.DeclareLocal(_valueType));

            context.InnerFill(_keyBuilder, key);
            context.InnerFill(_valueBuilder, value);

            g.BeginAssign(context.Member);
            {
                g.BeginNewObject(_ctor);
                {
                    g.Load(key);
                    g.Load(value);
                }
                g.EndNewObject();
            }
            g.EndAssign();
        }
        void IPartBuilder.GenerateFillPart(GenFillContext context)
        {
            var g = context.Generator;

            g.If(() =>
            {
                g.Load(context.NextIsNull);
                return(BinaryOperator.IsTrue);
            });
            {
                g.BeginAssign(context.Member);
                {
                    g.LoadNull();
                }
                g.EndAssign();
            }
            g.Else();
            {
                var array   = g.DeclareLocal(context.Member.Type);
                var element = g.CreateExpression(g.DeclareLocal(_elementType));

                g.BeginAssign(array);
                g.BeginNewArray(_elementType);
                {
                    g.Load(context.NextCollectionSize);
                }
                g.EndNewArray();
                g.EndAssign();

                var i = g.DeclareLocal(typeof(int));
                g.BeginAssign(i);
                g.Load(0);
                g.EndAssign();

                g.While(() =>
                {
                    g.Load(i);
                    g.Load(array);
                    g.LoadMember("Length");
                    return(BinaryOperator.LessThan);
                }, () =>
                {
                    context.InnerFill(_elementBuilder, element);

                    g.Load(array);
                    g.BeginStoreElement();
                    {
                        g.Load(i);
                        g.Load(element);
                    }
                    g.EndStoreElement();

                    g.BeginAssign(i);
                    {
                        g.Load(i);
                        g.Increment();
                    }
                    g.EndAssign();
                });

                g.BeginAssign(context.Member);
                {
                    g.Load(array);
                }
                g.EndAssign();
            }
            g.EndIf();
        }
Beispiel #5
0
        private void GenerateFillCollection(GenFillContext context, IVariable collection)
        {
            var g = context.Generator;

            var count   = g.DeclareLocal(typeof(int));
            var element = g.CreateExpression(g.DeclareLocal(_elementType));

            g.BeginAssign(count);
            g.Load(context.NextCollectionSize);
            g.EndAssign();

            g.While(() =>
            {
                g.Load(count);
                g.Load(0);
                return(BinaryOperator.GreaterThan);
            }, () =>
            {
                context.InnerFill(_innerBuilder, element);

                bool endIf = false;
                if (!_elementType.IsValueType)
                {
                    g.If(() =>
                    {
                        g.Load(element);
                        g.LoadNull();
                        return(BinaryOperator.AreNotEqual);
                    });
                    endIf = true;
                }
                else if (_elementType.IsGenericType && _elementType.GetGenericTypeDefinition() == typeof(KeyValuePair <,>))
                {
                    var keyType = _elementType.GetGenericArguments()[0];
                    if (!keyType.IsValueType)
                    {
                        g.If(() =>
                        {
                            g.Load(element, LoadOptions.ValueAsAddress);
                            g.LoadMember("Key");
                            g.LoadNull();
                            return(BinaryOperator.AreNotEqual);
                        });
                        endIf = true;
                    }
                }
                {
                    g.If(() =>
                    {
                        g.Load(collection);
                        g.BeginCall(_contains);
                        {
                            g.Load(element);
                        }
                        g.EndCall();
                        return(BinaryOperator.IsFalse);
                    });
                    {
                        g.Load(collection);
                        g.BeginCall(_add);
                        {
                            g.Load(element);
                        }
                        g.EndCall();
                    }
                    g.EndIf();
                }
                if (endIf)
                {
                    g.EndIf();
                }

                g.BeginAssign(count);
                {
                    g.Load(count);
                    g.Decrement();
                }
                g.EndAssign();
            });
        }