protected override void OnGetAddress(ILExpressed il)
 {
     OnGetAddress(il);
     var local = il.DeclareLocal("addressOf" + _info.Name, _info.PropertyType);
     il.Var.Set(local);
     il.Var.LoadAddress(local);
 }
 public DynamicReadTravellerBuilder(MethodBuilder builder, SerializableType target, TravellerContext context)
 {
     _target = target;
     _context = context;
     _il = builder.IL;
     _visitorVariable = new MethodArgILCodeVariable(1, typeof(IReadVisitor));
 }
        protected override void LoadAddress(ILExpressed il)
        {
            if (_valueAddressLoader == null)
                throw new NotSupportedException("This parameter does not support address loading");

            _valueAddressLoader.Invoke(il);
        }
Example #4
0
        void IILCode.Generate(ILExpressed il)
        {
            var instanceIsValueType = _instance != null && _instance.ParameterType != null && _instance.ParameterType.IsValueType;
            if (_instance != null) {
                if (instanceIsValueType)
                    _instance.LoadAddress(il);
                else
                    _instance.Load(il);
            }

            for (var i = 0; i < _parameters.Length; i++) {
                var parameter = (IILCodeParameter) _parameters[i] ?? ILCodeParameter.Null;

                var methodParameter = _methodParameters[i];

                if (methodParameter.IsOut)
                    parameter.LoadAddress(il);
                else
                    parameter.Load(il);
            }

            if (_method.IsStatic || instanceIsValueType)
                il.Call(_method);
            else
                il.CallVirt(_method);
        }
Example #5
0
        public ILStaticMethod(ILExpressed il, MethodInfo method)
        {
            if (!method.IsStatic)
                throw new ArgumentException("Static method is required");

            _il = il;
            _method = method;
        }
Example #6
0
        public ILInstanceMethod(ILExpressed il, MethodInfo method)
        {
            if (method.IsStatic)
                throw new ArgumentException("Instance method is required");

            _il = il;
            _method = method;
        }
 protected override void OnGet(ILExpressed il)
 {
     OpCode opCode;
     if (OpCodesLookups.LoadArg.TryGetValue(_index, out opCode))
         il.Gen.Emit(opCode);
     else
         il.Gen.Emit(OpCodes.Ldarg_S, _index);
 }
Example #8
0
 protected override void OnGet(ILExpressed il)
 {
     OpCode opCode;
     if (OpCodesLookups.GetLocal.TryGetValue(_local.LocalIndex, out opCode)) {
         il.Gen.Emit(opCode);
         return;
     }
     il.Gen.Emit(OpCodes.Ldloc_S, _local.LocalIndex);
 }
        void IILCode.Generate(ILExpressed il)
        {
            for (var i = 0; i < _parameters.Length; i++) {
                var parameter = (IILCodeParameter) _parameters[i] ?? ILCodeParameter.Null;
                parameter.Load(il);
            }

            il.Gen.Emit(OpCodes.Newobj, _constructor);
        }
        protected override void OnSet(ILExpressed il)
        {
            if (_instance.VariableType.IsValueType)
                il.Var.LoadAddress(_instance);
            else
                il.Var.Load(_instance);

            il.Gen.Emit(OpCodes.Stfld, _info);
        }
        protected override void OnSet(ILExpressed il)
        {
            if (_instance.VariableType.IsValueType)
                il.Var.LoadAddress(_instance);
            else
                il.Var.Load(_instance);

            if (VariableType.IsValueType)
                il.Call(_info.GetSetMethod());
            else
                il.CallVirt(_info.GetSetMethod());
        }
Example #12
0
        void IILCode.Generate(ILExpressed il)
        {
            var variableType = il.TypeCache.Extend(_enumerable.ParameterType);
            var collectionContainer = variableType.Container.AsCollection();

            if (collectionContainer == null)
                throw new InvalidOperationException("Could not enumerate the type " + variableType.Ref.FullName);

            var elementType = collectionContainer.ElementType;
            il.Var.Load(_enumerable);

            var enumerableType = typeof(IEnumerable<>).MakeGenericType(elementType);
            var getEnumeratorMethod = enumerableType.GetMethod("GetEnumerator");
            il.CallVirt(getEnumeratorMethod);

            var enumeratorType = typeof(IEnumerator<>).MakeGenericType(elementType);
            var itLocal = il.DeclareLocal("it", enumeratorType);
            il.Var.Set(itLocal);

            il.Try();

            var itHeadLabel = il.DefineLabel();
            var itBodyLabel = il.DefineLabel();
            il.TransferLong(itHeadLabel);
            var itVarLocal = il.DeclareLocal("cv", elementType);
            var getCurrentMethod = enumeratorType.GetProperty("Current").GetGetMethod();
            il.MarkLabel(itBodyLabel);
            il.Var.Load(itLocal);
            il.Call(getCurrentMethod);
            il.Var.Set(itVarLocal);

            _iterateBody.Invoke(il, itVarLocal);

            il.MarkLabel(itHeadLabel);
            il.Var.Load(itLocal);
            il.CallVirt(EnumeratorMoveNext);

            il.TransferLongIfTrue(itBodyLabel);

            il.Finally();
            il.Var.Load(itLocal);
            il.LoadNull();
            il.CompareEquals();

            var endLabel = il.DefineLabel();
            il.TransferLongIfTrue(endLabel);

            il.Var.Load(itLocal);
            il.CallVirt(DisposableDispose);

            il.MarkLabel(endLabel);
            il.EndTry();
        }
        protected override void Load(ILExpressed il)
        {
            _parameter.Load(il);

            var type = _parameter.ParameterType;

            if (!type.IsValueType) return;

            var ext = il.TypeCache.Extend(type);
            if (ext.Class == TypeClass.Nullable) return;

            il.Snippets.AsNullable(type);
        }
Example #14
0
        void IILCode.Generate(ILExpressed il)
        {
            var value = il.DeclareLocal("index", _initialValue.ParameterType);
            il.Snippets.SetVariable(value, _initialValue);

            var labelCondition = il.DefineLabel();
            il.TransferLong(labelCondition);

            var labelBody = il.DefineAndMarkLabel();
            _bodyHandler.Invoke(il, value);
            il.Snippets.Increment(value, _increment);

            il.MarkLabel(labelCondition);
            _conditionHandler.Invoke(il, value);

            il.TransferLongIfTrue(labelBody);
        }
Example #15
0
 public ILChainIf(ILExpressed il)
 {
     _il = il;
 }
Example #16
0
 void IILCodeVariable.Set(ILExpressed il)
 {
     OnSet(il);
 }
 public ILCodeVariableGenerator(ILExpressed il)
 {
     _il = il;
 }
Example #18
0
 protected virtual void OnSet(ILExpressed il)
 {
     throw new InvalidOperationException("Not possible to use this variable in a set operation, " + GetType().Name);
 }
Example #19
0
 public MethodBuilder(System.Reflection.Emit.MethodBuilder methodBuilder)
 {
     _methodBuilder = methodBuilder;
     _il = new ILExpressed(_methodBuilder.GetILGenerator());
 }
Example #20
0
 protected abstract void Load(ILExpressed il);
Example #21
0
 protected virtual void LoadAddress(ILExpressed il)
 {
     throw new NotSupportedException("This parameter does not support address loading, " + GetType().Name);
 }
Example #22
0
 void IILCodeVariable.GetAddress(ILExpressed il)
 {
     OnGetAddress(il);
 }
Example #23
0
 public ConstructorBuilder(System.Reflection.Emit.ConstructorBuilder builder)
 {
     _builder = builder;
     _il = new ILExpressed(builder.GetILGenerator());
 }
Example #24
0
 protected override void Load(ILExpressed il)
 {
     _parameter.Load(il);
     if (_parameter.ParameterType != _toType)
         il.Cast(_toType);
 }
Example #25
0
 protected override void OnGetAddress(ILExpressed il)
 {
     il.Gen.Emit(OpCodes.Ldloca_S, _local.LocalIndex);
 }
Example #26
0
 public ILCodeSnippets(ILExpressed il)
 {
     _il = il;
 }
Example #27
0
 void IILCodeParameter.Load(ILExpressed il)
 {
     Load(il);
 }
 protected override void OnSet(ILExpressed il)
 {
     il.Gen.Emit(OpCodes.Stsfld, _info);
 }
 protected override void OnGetAddress(ILExpressed il)
 {
     il.Gen.Emit(OpCodes.Ldarga_S, _index);
 }
Example #30
0
 void IILCodeParameter.LoadAddress(ILExpressed il)
 {
     LoadAddress(il);
 }