CompileAddress()

ByRefUpdater System.Linq.Expressions.Interpreter.LightCompiler.CompileAddress ( Expression node, int index )

inlineprivate

Definition at line 1678 of file LightCompiler.cs.

    {
        if (index != -1 || ShouldWritebackNode(node))
        {
            switch (node.NodeType)
            {
            case ExpressionType.Parameter:
                LoadLocalNoValueTypeCopy((ParameterExpression)node);
                return new ParameterByRefUpdater(ResolveLocal((ParameterExpression)node), index);
            case ExpressionType.ArrayIndex:
            {
                BinaryExpression binaryExpression = (BinaryExpression)node;
                return CompileArrayIndexAddress(binaryExpression.Left, binaryExpression.Right, index);
            }
            case ExpressionType.Index:
            {
                IndexExpression indexExpression = (IndexExpression)node;
                if (indexExpression.Indexer != null)
                {
                    LocalDefinition? obj = null;
                    if (indexExpression.Object != null)
                    {
                        obj = _locals.DefineLocal(Expression.Parameter(indexExpression.Object.Type), _instructions.Count);
                        EmitThisForMethodCall(indexExpression.Object);
                        _instructions.EmitDup();
                        _instructions.EmitStoreLocal(obj.GetValueOrDefault().Index);
                    }
                    int argumentCount = indexExpression.ArgumentCount;
                    LocalDefinition[] array = new LocalDefinition[argumentCount];
                    for (int i = 0; i < argumentCount; i++)
                    {
                        Expression argument = indexExpression.GetArgument(i);
                        Compile(argument);
                        LocalDefinition localDefinition = _locals.DefineLocal(Expression.Parameter(argument.Type), _instructions.Count);
                        _instructions.EmitDup();
                        _instructions.EmitStoreLocal(localDefinition.Index);
                        array[i] = localDefinition;
                    }
                    EmitIndexGet(indexExpression);
                    return new IndexMethodByRefUpdater(obj, array, indexExpression.Indexer.GetSetMethod(), index);
                }
                if (indexExpression.ArgumentCount == 1)
                {
                    return CompileArrayIndexAddress(indexExpression.Object, indexExpression.GetArgument(0), index);
                }
                return CompileMultiDimArrayAccess(indexExpression.Object, indexExpression, index);
            }
            case ExpressionType.MemberAccess:
            {
                MemberExpression memberExpression = (MemberExpression)node;
                LocalDefinition? obj2 = null;
                if (memberExpression.Expression != null)
                {
                    obj2 = _locals.DefineLocal(Expression.Parameter(memberExpression.Expression.Type, "member"), _instructions.Count);
                    EmitThisForMethodCall(memberExpression.Expression);
                    _instructions.EmitDup();
                    _instructions.EmitStoreLocal(obj2.GetValueOrDefault().Index);
                }
                FieldInfo fieldInfo = memberExpression.Member as FieldInfo;
                if (fieldInfo != null)
                {
                    _instructions.EmitLoadField(fieldInfo);
                    if (!fieldInfo.IsLiteral && !fieldInfo.IsInitOnly)
                    {
                        return new FieldByRefUpdater(obj2, fieldInfo, index);
                    }
                    return null;
                }
                PropertyInfo propertyInfo = (PropertyInfo)memberExpression.Member;
                _instructions.EmitCall(propertyInfo.GetGetMethod(nonPublic: true));
                if (propertyInfo.CanWrite)
                {
                    return new PropertyByRefUpdater(obj2, propertyInfo, index);
                }
                return null;
            }
            case ExpressionType.Call:
            {
                MethodCallExpression methodCallExpression = (MethodCallExpression)node;
                if (!methodCallExpression.Method.IsStatic && methodCallExpression.Object.Type.IsArray && methodCallExpression.Method == TypeUtils.GetArrayGetMethod(methodCallExpression.Object.Type))
                {
                    return CompileMultiDimArrayAccess(methodCallExpression.Object, methodCallExpression, index);
                }
                break;
            }
            }
        }
        Compile(node);
        return null;
    }

References System.Linq.Expressions.Interpreter.LightCompiler._instructions, System.Linq.Expressions.Interpreter.LightCompiler._locals, System.array, System.Reflection.PropertyInfo.CanWrite, System.Linq.Expressions.Interpreter.LightCompiler.Compile(), System.Linq.Expressions.Interpreter.LightCompiler.CompileArrayIndexAddress(), System.Linq.Expressions.Interpreter.LightCompiler.CompileMultiDimArrayAccess(), System.Linq.Expressions.Interpreter.InstructionList.Count, System.Linq.Expressions.Interpreter.LocalVariables.DefineLocal(), System.Linq.Expressions.Interpreter.InstructionList.EmitCall(), System.Linq.Expressions.Interpreter.InstructionList.EmitDup(), System.Linq.Expressions.Interpreter.LightCompiler.EmitIndexGet(), System.Linq.Expressions.Interpreter.InstructionList.EmitLoadField(), System.Linq.Expressions.Interpreter.InstructionList.EmitStoreLocal(), System.Linq.Expressions.Interpreter.LightCompiler.EmitThisForMethodCall(), System.Dynamic.Utils.TypeUtils.GetArrayGetMethod(), System.Reflection.PropertyInfo.GetGetMethod(), System.Linq.index, System.Linq.Expressions.Interpreter.LightCompiler.LoadLocalNoValueTypeCopy(), System.obj, System.Linq.Expressions.Expression< TDelegate >.Parameter(), System.Linq.Expressions.Interpreter.LightCompiler.ResolveLocal(), and System.Linq.Expressions.Interpreter.LightCompiler.ShouldWritebackNode().

Referenced by System.Linq.Expressions.Interpreter.LightCompiler.CompileConvertUnaryExpression(), System.Linq.Expressions.Interpreter.LightCompiler.CompileMethodCallExpression(), System.Linq.Expressions.Interpreter.LightCompiler.CompileNewExpression(), and System.Linq.Expressions.Interpreter.LightCompiler.EmitThisForMethodCall().