예제 #1
0
 internal override void AnalyzeUsage(RuleAnalysis analysis)
 {
     RuleExpressionWalker.AnalyzeUsage(analysis, this.assignStatement.Left, false, true, null);
     RuleExpressionWalker.AnalyzeUsage(analysis, this.assignStatement.Right, true, false, null);
 }
예제 #2
0
        internal override RuleExpressionInfo Validate(CodeExpression expression, RuleValidation validation, bool isWritten)
        {
            CodeArrayCreateExpression newParent = (CodeArrayCreateExpression)expression;

            if (isWritten)
            {
                ValidationError item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CannotWriteToExpression, new object[] { typeof(CodeObjectCreateExpression).ToString() }), 0x17a);
                item.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(item);
                return(null);
            }
            if (newParent.CreateType == null)
            {
                ValidationError error2 = new ValidationError(Messages.NullTypeType, 0x53d);
                error2.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(error2);
                return(null);
            }
            Type lhsType = validation.ResolveType(newParent.CreateType);

            if (lhsType == null)
            {
                return(null);
            }
            if (lhsType.IsArray)
            {
                ValidationError error3 = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.ArrayTypeInvalid, new object[] { lhsType.Name }), 0x53d);
                error3.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(error3);
                return(null);
            }
            try
            {
                if (!validation.PushParentExpression(newParent))
                {
                    return(null);
                }
                if (newParent.Size < 0)
                {
                    ValidationError error4 = new ValidationError(Messages.ArraySizeInvalid, 0x53d);
                    error4.UserData["ErrorObject"] = newParent;
                    validation.Errors.Add(error4);
                    return(null);
                }
                if (newParent.SizeExpression != null)
                {
                    RuleExpressionInfo info = RuleExpressionWalker.Validate(validation, newParent.SizeExpression, false);
                    if (info == null)
                    {
                        return(null);
                    }
                    if (((info.ExpressionType != typeof(int)) && (info.ExpressionType != typeof(uint))) && ((info.ExpressionType != typeof(long)) && (info.ExpressionType != typeof(ulong))))
                    {
                        ValidationError error5 = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.ArraySizeTypeInvalid, new object[] { info.ExpressionType.Name }), 0x53d);
                        error5.UserData["ErrorObject"] = newParent;
                        validation.Errors.Add(error5);
                        return(null);
                    }
                }
                bool flag = false;
                for (int i = 0; i < newParent.Initializers.Count; i++)
                {
                    CodeExpression expression3 = newParent.Initializers[i];
                    if (expression3 == null)
                    {
                        ValidationError error6 = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.MissingInitializer, new object[] { lhsType.Name }), 0x53d);
                        error6.UserData["ErrorObject"] = newParent;
                        validation.Errors.Add(error6);
                        return(null);
                    }
                    RuleExpressionInfo info2 = RuleExpressionWalker.Validate(validation, expression3, false);
                    if (info2 == null)
                    {
                        flag = true;
                    }
                    else
                    {
                        ValidationError error7;
                        if (!RuleValidation.StandardImplicitConversion(info2.ExpressionType, lhsType, expression3, out error7))
                        {
                            if (error7 != null)
                            {
                                error7.UserData["ErrorObject"] = newParent;
                                validation.Errors.Add(error7);
                            }
                            error7 = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.InitializerMismatch, new object[] { i, lhsType.Name }), 0x545);
                            error7.UserData["ErrorObject"] = newParent;
                            validation.Errors.Add(error7);
                            return(null);
                        }
                    }
                }
                if (flag)
                {
                    return(null);
                }
                double size = -1.0;
                if (newParent.SizeExpression != null)
                {
                    CodePrimitiveExpression sizeExpression = newParent.SizeExpression as CodePrimitiveExpression;
                    if ((sizeExpression != null) && (sizeExpression.Value != null))
                    {
                        size = (double)Executor.AdjustType(sizeExpression.Value.GetType(), sizeExpression.Value, typeof(double));
                    }
                    if (newParent.Size > 0)
                    {
                        ValidationError error8 = new ValidationError(Messages.ArraySizeBoth, 0x53d);
                        error8.UserData["ErrorObject"] = newParent;
                        validation.Errors.Add(error8);
                        return(null);
                    }
                }
                else if (newParent.Size > 0)
                {
                    size = newParent.Size;
                }
                if ((size >= 0.0) && (newParent.Initializers.Count > size))
                {
                    ValidationError error9 = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.InitializerCountMismatch, new object[] { newParent.Initializers.Count, size }), 0x545);
                    error9.UserData["ErrorObject"] = newParent;
                    validation.Errors.Add(error9);
                    return(null);
                }
            }
            finally
            {
                validation.PopParentExpression();
            }
            return(new RuleExpressionInfo(lhsType.MakeArrayType()));
        }
예제 #3
0
        internal override RuleExpressionResult Evaluate(CodeExpression expression, RuleExecution execution)
        {
            CodeArrayCreateExpression expression2 = (CodeArrayCreateExpression)expression;

            if (expression2.CreateType == null)
            {
                RuleEvaluationException exception = new RuleEvaluationException(Messages.NullTypeType);
                exception.Data["ErrorObject"] = expression2;
                throw exception;
            }
            RuleExpressionInfo info = execution.Validation.ExpressionInfo(expression2);

            if (expression2 == null)
            {
                InvalidOperationException exception2 = new InvalidOperationException(Messages.ExpressionNotValidated);
                exception2.Data["ErrorObject"] = expression2;
                throw exception2;
            }
            Type elementType = info.ExpressionType.GetElementType();
            int  length      = 0;

            if (expression2.SizeExpression != null)
            {
                Type expressionType         = execution.Validation.ExpressionInfo(expression2.SizeExpression).ExpressionType;
                RuleExpressionResult result = RuleExpressionWalker.Evaluate(execution, expression2.SizeExpression);
                if (expressionType == typeof(int))
                {
                    length = (int)result.Value;
                }
                else if (expressionType == typeof(long))
                {
                    length = (int)((long)result.Value);
                }
                else if (expressionType == typeof(uint))
                {
                    length = (int)((uint)result.Value);
                }
                else if (expressionType == typeof(ulong))
                {
                    length = (int)((ulong)result.Value);
                }
            }
            else if (expression2.Size != 0)
            {
                length = expression2.Size;
            }
            else
            {
                length = expression2.Initializers.Count;
            }
            Array literal = Array.CreateInstance(elementType, length);

            if (expression2.Initializers != null)
            {
                for (int i = 0; i < expression2.Initializers.Count; i++)
                {
                    CodeExpression       expression3 = expression2.Initializers[i];
                    Type                 operandType = execution.Validation.ExpressionInfo(expression3).ExpressionType;
                    RuleExpressionResult result2     = RuleExpressionWalker.Evaluate(execution, expression3);
                    literal.SetValue(Executor.AdjustType(operandType, result2.Value, elementType), i);
                }
            }
            return(new RuleLiteralResult(literal));
        }
        internal override RuleExpressionInfo Validate(CodeExpression expression, RuleValidation validation, bool isWritten)
        {
            RuleExpressionInfo info;
            bool flag;
            CodeDirectionExpression expression2 = (CodeDirectionExpression)expression;

            if (isWritten)
            {
                ValidationError item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CannotWriteToExpression, new object[] { typeof(CodeDirectionExpression).ToString() }), 0x17a);
                item.UserData["ErrorObject"] = expression2;
                validation.Errors.Add(item);
                return(null);
            }
            if (expression2.Expression == null)
            {
                ValidationError error2 = new ValidationError(Messages.NullDirectionTarget, 0x53d);
                error2.UserData["ErrorObject"] = expression2;
                validation.Errors.Add(error2);
                return(null);
            }
            if (expression2.Expression is CodeTypeReferenceExpression)
            {
                ValidationError error = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CodeExpressionNotHandled, new object[] { expression2.Expression.GetType().FullName }), 0x548);
                error.UserData["ErrorObject"] = expression2.Expression;
                validation.AddError(error);
                return(null);
            }
            if (expression2.Direction == FieldDirection.Ref)
            {
                flag = true;
                if (RuleExpressionWalker.Validate(validation, expression2.Expression, false) == null)
                {
                    return(null);
                }
                info = RuleExpressionWalker.Validate(validation, expression2.Expression, true);
            }
            else if (expression2.Direction == FieldDirection.Out)
            {
                flag = true;
                info = RuleExpressionWalker.Validate(validation, expression2.Expression, true);
            }
            else
            {
                flag = false;
                info = RuleExpressionWalker.Validate(validation, expression2.Expression, false);
            }
            if (info == null)
            {
                return(null);
            }
            Type expressionType = info.ExpressionType;

            if (expressionType == null)
            {
                return(null);
            }
            if (((expressionType != typeof(NullLiteral)) && flag) && !expressionType.IsByRef)
            {
                expressionType = expressionType.MakeByRefType();
            }
            return(new RuleExpressionInfo(expressionType));
        }
        internal override RuleExpressionInfo Validate(CodeExpression expression, RuleValidation validation, bool isWritten)
        {
            ValidationError            item           = null;
            Type                       expressionType = null;
            CodeArrayIndexerExpression newParent      = (CodeArrayIndexerExpression)expression;
            CodeExpression             targetObject   = newParent.TargetObject;

            if (targetObject == null)
            {
                item = new ValidationError(Messages.NullIndexerTarget, 0x53d);
                item.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(item);
                return(null);
            }
            if (targetObject is CodeTypeReferenceExpression)
            {
                item = new ValidationError(Messages.IndexersCannotBeStatic, 0x53d);
                item.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(item);
                return(null);
            }
            if ((newParent.Indices == null) || (newParent.Indices.Count == 0))
            {
                item = new ValidationError(Messages.MissingIndexExpressions, 0x53d);
                item.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(item);
                return(null);
            }
            try
            {
                if (!validation.PushParentExpression(newParent))
                {
                    return(null);
                }
                RuleExpressionInfo info = RuleExpressionWalker.Validate(validation, newParent.TargetObject, false);
                if (info == null)
                {
                    return(null);
                }
                expressionType = info.ExpressionType;
                if (expressionType == null)
                {
                    return(null);
                }
                if (expressionType == typeof(NullLiteral))
                {
                    item = new ValidationError(Messages.NullIndexerTarget, 0x53d);
                    item.UserData["ErrorObject"] = newParent;
                    validation.Errors.Add(item);
                    return(null);
                }
                if (!expressionType.IsArray)
                {
                    item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CannotIndexType, new object[] { RuleDecompiler.DecompileType(expressionType) }), 0x19b);
                    item.UserData["ErrorObject"] = newParent;
                    validation.Errors.Add(item);
                    return(null);
                }
                int arrayRank = expressionType.GetArrayRank();
                if (newParent.Indices.Count != arrayRank)
                {
                    item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.ArrayIndexBadRank, new object[] { arrayRank }), 0x19c);
                    item.UserData["ErrorObject"] = newParent;
                    validation.Errors.Add(item);
                    return(null);
                }
                bool flag = false;
                for (int i = 0; i < newParent.Indices.Count; i++)
                {
                    CodeExpression expression4 = newParent.Indices[i];
                    if (expression4 == null)
                    {
                        item = new ValidationError(Messages.NullIndexExpression, 0x53d);
                        item.UserData["ErrorObject"] = newParent;
                        validation.Errors.Add(item);
                        flag = true;
                        continue;
                    }
                    if (expression4 is CodeDirectionExpression)
                    {
                        item = new ValidationError(Messages.IndexerArgCannotBeRefOrOut, 0x19d);
                        item.UserData["ErrorObject"] = expression4;
                        validation.Errors.Add(item);
                        flag = true;
                    }
                    if (expression4 is CodeTypeReferenceExpression)
                    {
                        item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CodeExpressionNotHandled, new object[] { expression4.GetType().FullName }), 0x548);
                        item.UserData["ErrorObject"] = expression4;
                        validation.AddError(item);
                        flag = true;
                    }
                    RuleExpressionInfo info2 = RuleExpressionWalker.Validate(validation, expression4, false);
                    if (info2 != null)
                    {
                        Type type = info2.ExpressionType;
                        switch (Type.GetTypeCode(type))
                        {
                        case TypeCode.Char:
                        case TypeCode.SByte:
                        case TypeCode.Byte:
                        case TypeCode.Int16:
                        case TypeCode.UInt16:
                        case TypeCode.Int32:
                        case TypeCode.Int64:
                        {
                            continue;
                        }
                        }
                        item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.ArrayIndexBadType, new object[] { RuleDecompiler.DecompileType(type) }), 0x19e);
                        item.UserData["ErrorObject"] = expression4;
                        validation.Errors.Add(item);
                        flag = true;
                        continue;
                    }
                    flag = true;
                }
                if (flag)
                {
                    return(null);
                }
            }
            finally
            {
                validation.PopParentExpression();
            }
            return(new RuleExpressionInfo(expressionType.GetElementType()));
        }
예제 #6
0
        internal override bool Validate(RuleValidation validation)
        {
            bool flag = false;
            RuleExpressionInfo info = null;

            if (this.assignStatement.Left == null)
            {
                ValidationError item = new ValidationError(Messages.NullAssignLeft, 0x541);
                item.UserData["ErrorObject"] = this.assignStatement;
                validation.Errors.Add(item);
            }
            else
            {
                info = validation.ExpressionInfo(this.assignStatement.Left);
                if (info == null)
                {
                    info = RuleExpressionWalker.Validate(validation, this.assignStatement.Left, true);
                }
            }
            RuleExpressionInfo info2 = null;

            if (this.assignStatement.Right == null)
            {
                ValidationError error2 = new ValidationError(Messages.NullAssignRight, 0x543);
                error2.UserData["ErrorObject"] = this.assignStatement;
                validation.Errors.Add(error2);
            }
            else
            {
                info2 = RuleExpressionWalker.Validate(validation, this.assignStatement.Right, false);
            }
            if ((info == null) || (info2 == null))
            {
                return(flag);
            }
            Type expressionType = info2.ExpressionType;
            Type lhsType        = info.ExpressionType;

            if (lhsType == typeof(NullLiteral))
            {
                ValidationError error3 = new ValidationError(Messages.NullAssignLeft, 0x542);
                error3.UserData["ErrorObject"] = this.assignStatement;
                validation.Errors.Add(error3);
                return(false);
            }
            if (lhsType != expressionType)
            {
                ValidationError error = null;
                if (!RuleValidation.TypesAreAssignable(expressionType, lhsType, this.assignStatement.Right, out error))
                {
                    if (error == null)
                    {
                        error = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.AssignNotAllowed, new object[] { RuleDecompiler.DecompileType(expressionType), RuleDecompiler.DecompileType(lhsType) }), 0x545);
                    }
                    error.UserData["ErrorObject"] = this.assignStatement;
                    validation.Errors.Add(error);
                    return(flag);
                }
            }
            return(true);
        }
        internal override RuleExpressionInfo Validate(CodeExpression expression, RuleValidation validation, bool isWritten)
        {
            CodeFieldReferenceExpression newParent = (CodeFieldReferenceExpression)expression;

            if (newParent.TargetObject == null)
            {
                ValidationError item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.NullFieldTarget, new object[] { newParent.FieldName }), 0x53d);
                item.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(item);
                return(null);
            }
            if (!validation.PushParentExpression(newParent))
            {
                return(null);
            }
            RuleExpressionInfo info = RuleExpressionWalker.Validate(validation, newParent.TargetObject, false);

            validation.PopParentExpression();
            if (info == null)
            {
                return(null);
            }
            Type expressionType = info.ExpressionType;

            if (expressionType == null)
            {
                return(null);
            }
            if (expressionType == typeof(NullLiteral))
            {
                ValidationError error2 = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.NullFieldTarget, new object[] { newParent.FieldName }), 0x546);
                error2.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(error2);
                return(null);
            }
            BindingFlags @public = BindingFlags.Public;

            if (newParent.TargetObject is CodeTypeReferenceExpression)
            {
                @public |= BindingFlags.FlattenHierarchy | BindingFlags.Static;
            }
            else
            {
                @public |= BindingFlags.Instance;
            }
            if (validation.AllowInternalMembers(expressionType))
            {
                @public |= BindingFlags.NonPublic;
            }
            FieldInfo field = expressionType.GetField(newParent.FieldName, @public);

            if (field == null)
            {
                ValidationError error3 = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.UnknownField, new object[] { newParent.FieldName, RuleDecompiler.DecompileType(expressionType) }), 0x54a);
                error3.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(error3);
                return(null);
            }
            if (field.FieldType == null)
            {
                ValidationError error4 = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CouldNotDetermineMemberType, new object[] { newParent.FieldName }), 0x194);
                error4.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(error4);
                return(null);
            }
            if (isWritten && field.IsLiteral)
            {
                ValidationError error5 = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.FieldSetNotAllowed, new object[] { newParent.FieldName, RuleDecompiler.DecompileType(expressionType) }), 0x17a);
                error5.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(error5);
                return(null);
            }
            if (!validation.ValidateMemberAccess(newParent.TargetObject, expressionType, field, field.Name, newParent))
            {
                return(null);
            }
            validation.IsAuthorized(field.FieldType);
            return(new RuleFieldExpressionInfo(field));
        }
예제 #8
0
        internal override RuleExpressionInfo Validate(CodeExpression expression, RuleValidation validation, bool isWritten)
        {
            CodePropertyReferenceExpression newParent = (CodePropertyReferenceExpression)expression;

            if (newParent.TargetObject == null)
            {
                ValidationError error = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.NullPropertyTarget, new object[] { newParent.PropertyName }), 0x53d);
                error.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(error);
                return(null);
            }
            if (!validation.PushParentExpression(newParent))
            {
                return(null);
            }
            RuleExpressionInfo info = RuleExpressionWalker.Validate(validation, newParent.TargetObject, false);

            validation.PopParentExpression();
            if (info == null)
            {
                return(null);
            }
            Type expressionType = info.ExpressionType;

            if (expressionType == null)
            {
                return(null);
            }
            if (expressionType == typeof(NullLiteral))
            {
                ValidationError error2 = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.NullPropertyTarget, new object[] { newParent.PropertyName }), 0x546);
                error2.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(error2);
                return(null);
            }
            bool         nonPublic    = false;
            BindingFlags bindingFlags = BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance;

            if (validation.AllowInternalMembers(expressionType))
            {
                bindingFlags |= BindingFlags.NonPublic;
                nonPublic     = true;
            }
            PropertyInfo item = validation.ResolveProperty(expressionType, newParent.PropertyName, bindingFlags);

            if (item == null)
            {
                ValidationError error3 = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.UnknownProperty, new object[] { newParent.PropertyName, RuleDecompiler.DecompileType(expressionType) }), 0x54a);
                error3.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(error3);
                return(null);
            }
            if (item.PropertyType == null)
            {
                ValidationError error4 = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CouldNotDetermineMemberType, new object[] { newParent.PropertyName }), 0x194);
                error4.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(error4);
                return(null);
            }
            MethodInfo accessorMethod = isWritten ? item.GetSetMethod(nonPublic) : item.GetGetMethod(nonPublic);

            if (accessorMethod == null)
            {
                string          format = isWritten ? Messages.UnknownPropertySet : Messages.UnknownPropertyGet;
                ValidationError error5 = new ValidationError(string.Format(CultureInfo.CurrentCulture, format, new object[] { newParent.PropertyName, RuleDecompiler.DecompileType(expressionType) }), 0x54a);
                error5.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(error5);
                return(null);
            }
            if (!validation.ValidateMemberAccess(newParent.TargetObject, expressionType, accessorMethod, newParent.PropertyName, newParent))
            {
                return(null);
            }
            object[] customAttributes = item.GetCustomAttributes(typeof(RuleAttribute), true);
            if ((customAttributes != null) && (customAttributes.Length > 0))
            {
                Stack <MemberInfo> stack = new Stack <MemberInfo>();
                stack.Push(item);
                bool flag2 = true;
                foreach (RuleAttribute attribute in customAttributes)
                {
                    if (!attribute.Validate(validation, item, expressionType, null))
                    {
                        flag2 = false;
                    }
                }
                stack.Pop();
                if (!flag2)
                {
                    return(null);
                }
            }
            return(new RulePropertyExpressionInfo(item, item.PropertyType, false));
        }
 internal void AnalyzeReadWrite(RuleAnalysis analysis, CodeExpression targetExpression, RulePathQualifier targetQualifier, CodeExpressionCollection argumentExpressions, ParameterInfo[] parameters, List <CodeExpression> attributedExpressions)
 {
     if (string.IsNullOrEmpty(this.attributePath))
     {
         if (this.attributeTarget == RuleAttributeTarget.This)
         {
             attributedExpressions.Add(targetExpression);
         }
         else if (this.attributeTarget == RuleAttributeTarget.Parameter)
         {
             for (int i = 0; i < argumentExpressions.Count; i++)
             {
                 attributedExpressions.Add(argumentExpressions[i]);
             }
         }
     }
     else
     {
         string attributePath = this.attributePath;
         bool   isRead        = !analysis.ForWrites;
         bool   forWrites     = analysis.ForWrites;
         if (this.attributeTarget == RuleAttributeTarget.This)
         {
             string str2 = "this/";
             if (attributePath.StartsWith(str2, StringComparison.Ordinal))
             {
                 attributePath = attributePath.Substring(str2.Length);
             }
             RuleExpressionWalker.AnalyzeUsage(analysis, targetExpression, isRead, forWrites, new RulePathQualifier(attributePath, targetQualifier));
             attributedExpressions.Add(targetExpression);
         }
         else if (this.attributeTarget == RuleAttributeTarget.Parameter)
         {
             string paramName = null;
             int    index     = attributePath.IndexOf('/');
             if (index >= 0)
             {
                 paramName     = attributePath.Substring(0, index);
                 attributePath = attributePath.Substring(index + 1);
             }
             else
             {
                 paramName     = attributePath;
                 attributePath = null;
             }
             ParameterInfo info = Array.Find <ParameterInfo>(parameters, p => p.Name == paramName);
             if (info != null)
             {
                 RulePathQualifier qualifier = string.IsNullOrEmpty(attributePath) ? null : new RulePathQualifier(attributePath, null);
                 int count = info.Position + 1;
                 if (info.Position == (parameters.Length - 1))
                 {
                     count = argumentExpressions.Count;
                 }
                 for (int j = info.Position; j < count; j++)
                 {
                     CodeExpression expression = argumentExpressions[j];
                     RuleExpressionWalker.AnalyzeUsage(analysis, expression, isRead, forWrites, qualifier);
                     attributedExpressions.Add(expression);
                 }
             }
         }
     }
 }
 internal override void Execute(RuleExecution execution)
 {
     RuleExpressionWalker.Evaluate(execution, this.exprStatement.Expression);
 }
        internal override bool Match(CodeStatement comperand)
        {
            CodeExpressionStatement statement = comperand as CodeExpressionStatement;

            return((statement != null) && RuleExpressionWalker.Match(this.exprStatement.Expression, statement.Expression));
        }
 internal override CodeStatement Clone()
 {
     return(new CodeExpressionStatement {
         Expression = RuleExpressionWalker.Clone(this.exprStatement.Expression)
     });
 }
 internal override void AnalyzeUsage(RuleAnalysis analysis)
 {
     RuleExpressionWalker.AnalyzeUsage(analysis, this.exprStatement.Expression, false, false, null);
 }
예제 #14
0
        internal override bool Validate(RuleValidation validation)
        {
            bool               success = false;
            string             message;
            RuleExpressionInfo lhsExprInfo = null;

            if (assignStatement.Left == null)
            {
                ValidationError error = new ValidationError(Messages.NullAssignLeft, ErrorNumbers.Error_LeftOperandMissing);
                error.UserData[RuleUserDataKeys.ErrorObject] = assignStatement;
                validation.Errors.Add(error);
            }
            else
            {
                lhsExprInfo = validation.ExpressionInfo(assignStatement.Left);
                if (lhsExprInfo == null)
                {
                    lhsExprInfo = RuleExpressionWalker.Validate(validation, assignStatement.Left, true);
                }
            }

            RuleExpressionInfo rhsExprInfo = null;

            if (assignStatement.Right == null)
            {
                ValidationError error = new ValidationError(Messages.NullAssignRight, ErrorNumbers.Error_RightOperandMissing);
                error.UserData[RuleUserDataKeys.ErrorObject] = assignStatement;
                validation.Errors.Add(error);
            }
            else
            {
                rhsExprInfo = RuleExpressionWalker.Validate(validation, assignStatement.Right, false);
            }

            if (lhsExprInfo != null && rhsExprInfo != null)
            {
                Type expressionType = rhsExprInfo.ExpressionType;
                Type assignmentType = lhsExprInfo.ExpressionType;

                if (assignmentType == typeof(NullLiteral))
                {
                    // Can't assign to a null literal.
                    ValidationError error = new ValidationError(Messages.NullAssignLeft, ErrorNumbers.Error_LeftOperandInvalidType);
                    error.UserData[RuleUserDataKeys.ErrorObject] = assignStatement;
                    validation.Errors.Add(error);
                    success = false;
                }
                else if (assignmentType == expressionType)
                {
                    // Easy case, they're both the same type.
                    success = true;
                }
                else
                {
                    // The types aren't the same, but it still might be a legal assignment.
                    ValidationError error = null;
                    if (!RuleValidation.TypesAreAssignable(expressionType, assignmentType, assignStatement.Right, out error))
                    {
                        if (error == null)
                        {
                            message = string.Format(CultureInfo.CurrentCulture, Messages.AssignNotAllowed, RuleDecompiler.DecompileType(expressionType), RuleDecompiler.DecompileType(assignmentType));
                            error   = new ValidationError(message, ErrorNumbers.Error_OperandTypesIncompatible);
                        }
                        error.UserData[RuleUserDataKeys.ErrorObject] = assignStatement;
                        validation.Errors.Add(error);
                    }
                    else
                    {
                        success = true;
                    }
                }
            }

            return(success);
        }
예제 #15
0
 internal override CodeStatement Clone()
 {
     return(new CodeAssignStatement {
         Left = RuleExpressionWalker.Clone(this.assignStatement.Left), Right = RuleExpressionWalker.Clone(this.assignStatement.Right)
     });
 }
예제 #16
0
        internal override RuleExpressionResult Evaluate(CodeExpression expression, RuleExecution execution)
        {
            object obj3;
            CodeMethodInvokeExpression expression2 = (CodeMethodInvokeExpression)expression;
            object obj2 = RuleExpressionWalker.Evaluate(execution, expression2.Method.TargetObject).Value;
            RuleMethodInvokeExpressionInfo info = execution.Validation.ExpressionInfo(expression2) as RuleMethodInvokeExpressionInfo;

            if (info == null)
            {
                InvalidOperationException exception = new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.ExpressionNotValidated, new object[0]));
                exception.Data["ErrorObject"] = expression2;
                throw exception;
            }
            MethodInfo methodInfo = info.MethodInfo;

            if (!methodInfo.IsStatic && (obj2 == null))
            {
                RuleEvaluationException exception2 = new RuleEvaluationException(string.Format(CultureInfo.CurrentCulture, Messages.TargetEvaluatedNullMethod, new object[] { expression2.Method.MethodName }));
                exception2.Data["ErrorObject"] = expression2;
                throw exception2;
            }
            object[] parameters = null;
            RuleExpressionResult[] resultArray = null;
            if ((expression2.Parameters != null) && (expression2.Parameters.Count > 0))
            {
                int             count     = expression2.Parameters.Count;
                ParameterInfo[] infoArray = methodInfo.GetParameters();
                parameters = new object[infoArray.Length];
                int length = infoArray.Length;
                if (info.NeedsParamsExpansion)
                {
                    length--;
                }
                int index = 0;
                while (index < length)
                {
                    Type expressionType                 = execution.Validation.ExpressionInfo(expression2.Parameters[index]).ExpressionType;
                    RuleExpressionResult    result      = RuleExpressionWalker.Evaluate(execution, expression2.Parameters[index]);
                    CodeDirectionExpression expression3 = expression2.Parameters[index] as CodeDirectionExpression;
                    if ((expression3 != null) && ((expression3.Direction == FieldDirection.Ref) || (expression3.Direction == FieldDirection.Out)))
                    {
                        if (resultArray == null)
                        {
                            resultArray = new RuleExpressionResult[expression2.Parameters.Count];
                        }
                        resultArray[index] = result;
                        if (expression3.Direction != FieldDirection.Out)
                        {
                            parameters[index] = Executor.AdjustType(expressionType, result.Value, infoArray[index].ParameterType);
                        }
                    }
                    else
                    {
                        parameters[index] = Executor.AdjustType(expressionType, result.Value, infoArray[index].ParameterType);
                    }
                    index++;
                }
                if (length < count)
                {
                    ParameterInfo info3         = infoArray[length];
                    Type          parameterType = info3.ParameterType;
                    Type          elementType   = parameterType.GetElementType();
                    Array         array         = (Array)parameterType.InvokeMember(parameterType.Name, BindingFlags.CreateInstance, null, null, new object[] { count - index }, CultureInfo.CurrentCulture);
                    while (index < count)
                    {
                        Type operandType             = execution.Validation.ExpressionInfo(expression2.Parameters[index]).ExpressionType;
                        RuleExpressionResult result2 = RuleExpressionWalker.Evaluate(execution, expression2.Parameters[index]);
                        array.SetValue(Executor.AdjustType(operandType, result2.Value, elementType), (int)(index - length));
                        index++;
                    }
                    parameters[length] = array;
                }
            }
            try
            {
                obj3 = methodInfo.Invoke(obj2, parameters);
            }
            catch (TargetInvocationException exception3)
            {
                if (exception3.InnerException == null)
                {
                    throw;
                }
                throw new TargetInvocationException(string.Format(CultureInfo.CurrentCulture, Messages.Error_MethodInvoke, new object[] { RuleDecompiler.DecompileType(methodInfo.ReflectedType), methodInfo.Name, exception3.InnerException.Message }), exception3.InnerException);
            }
            if (resultArray != null)
            {
                for (int i = 0; i < expression2.Parameters.Count; i++)
                {
                    if (resultArray[i] != null)
                    {
                        resultArray[i].Value = parameters[i];
                    }
                }
            }
            return(new RuleLiteralResult(obj3));
        }
예제 #17
0
        internal override bool Match(CodeStatement comperand)
        {
            CodeAssignStatement statement = comperand as CodeAssignStatement;

            return(((statement != null) && RuleExpressionWalker.Match(this.assignStatement.Left, statement.Left)) && RuleExpressionWalker.Match(this.assignStatement.Right, statement.Right));
        }
예제 #18
0
        internal override RuleExpressionInfo Validate(CodeExpression expression, RuleValidation validation, bool isWritten)
        {
            Type expressionType = null;
            RuleMethodInvokeExpressionInfo info  = null;
            ValidationError            item      = null;
            BindingFlags               @public   = BindingFlags.Public;
            CodeMethodInvokeExpression newParent = (CodeMethodInvokeExpression)expression;

            if (isWritten)
            {
                item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CannotWriteToExpression, new object[] { typeof(CodeMethodInvokeExpression).ToString() }), 0x17a);
                item.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(item);
                return(null);
            }
            if ((newParent.Method == null) || (newParent.Method.TargetObject == null))
            {
                item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.NullMethodTarget, new object[] { newParent.Method.MethodName }), 0x53d);
                item.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(item);
                return(null);
            }
            if ((newParent.Method.TypeArguments != null) && (newParent.Method.TypeArguments.Count > 0))
            {
                item = new ValidationError(Messages.GenericMethodsNotSupported, 0x548);
                item.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(item);
                return(null);
            }
            try
            {
                if (!validation.PushParentExpression(newParent))
                {
                    return(null);
                }
                RuleExpressionInfo info2 = RuleExpressionWalker.Validate(validation, newParent.Method.TargetObject, false);
                if (info2 == null)
                {
                    return(null);
                }
                expressionType = info2.ExpressionType;
                if (expressionType == null)
                {
                    return(null);
                }
                if (expressionType == typeof(NullLiteral))
                {
                    item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.NullMethodTarget, new object[] { newParent.Method.MethodName }), 0x546);
                    item.UserData["ErrorObject"] = newParent;
                    validation.Errors.Add(item);
                    expressionType = null;
                }
                List <CodeExpression> argumentExprs = new List <CodeExpression>();
                bool flag = false;
                if (newParent.Parameters != null)
                {
                    for (int i = 0; i < newParent.Parameters.Count; i++)
                    {
                        CodeExpression expression3 = newParent.Parameters[i];
                        if (expression3 == null)
                        {
                            item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.NullMethodParameter, new object[] { i.ToString(CultureInfo.CurrentCulture), newParent.Method.MethodName }), 0x53d);
                            item.UserData["ErrorObject"] = newParent;
                            validation.Errors.Add(item);
                            expressionType = null;
                        }
                        else
                        {
                            if (expression3 is CodeTypeReferenceExpression)
                            {
                                item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CodeExpressionNotHandled, new object[] { expression3.GetType().FullName }), 0x548);
                                item.UserData["ErrorObject"] = expression3;
                                validation.AddError(item);
                                flag = true;
                            }
                            if (RuleExpressionWalker.Validate(validation, expression3, false) == null)
                            {
                                flag = true;
                            }
                            argumentExprs.Add(expression3);
                        }
                    }
                }
                if (expressionType == null)
                {
                    return(null);
                }
                if (flag)
                {
                    return(null);
                }
                if (newParent.Method.TargetObject is CodeTypeReferenceExpression)
                {
                    @public |= BindingFlags.FlattenHierarchy | BindingFlags.Static;
                }
                else
                {
                    @public |= BindingFlags.Instance;
                }
                if (validation.AllowInternalMembers(expressionType))
                {
                    @public |= BindingFlags.NonPublic;
                }
                info = validation.ResolveMethod(expressionType, newParent.Method.MethodName, @public, argumentExprs, out item);
                if ((info == null) && newParent.UserData.Contains("QualifiedName"))
                {
                    string qualifiedName = newParent.UserData["QualifiedName"] as string;
                    Type   type2         = validation.ResolveType(qualifiedName);
                    if (type2 != null)
                    {
                        validation.DetermineExtensionMethods(type2.Assembly);
                        info = validation.ResolveMethod(expressionType, newParent.Method.MethodName, @public, argumentExprs, out item);
                    }
                }
                if (info == null)
                {
                    item.UserData["ErrorObject"] = newParent;
                    validation.Errors.Add(item);
                    return(null);
                }
            }
            finally
            {
                validation.PopParentExpression();
            }
            MethodInfo methodInfo = info.MethodInfo;

            if (methodInfo.ReturnType == null)
            {
                item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CouldNotDetermineMemberType, new object[] { newParent.Method.MethodName }), 0x194);
                item.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(item);
                return(null);
            }
            if (!validation.ValidateMemberAccess(newParent.Method.TargetObject, expressionType, methodInfo, newParent.Method.MethodName, newParent))
            {
                return(null);
            }
            object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuleAttribute), true);
            if ((customAttributes != null) && (customAttributes.Length > 0))
            {
                Stack <MemberInfo> stack = new Stack <MemberInfo>();
                stack.Push(methodInfo);
                bool flag2 = true;
                foreach (RuleAttribute attribute in customAttributes)
                {
                    if (!attribute.Validate(validation, methodInfo, expressionType, methodInfo.GetParameters()))
                    {
                        flag2 = false;
                    }
                }
                stack.Pop();
                if (!flag2)
                {
                    return(null);
                }
            }
            if (methodInfo is ExtensionMethodInfo)
            {
                newParent.UserData["QualifiedName"] = methodInfo.DeclaringType.AssemblyQualifiedName;
            }
            return(info);
        }
        public override bool Equals(object obj)
        {
            bool flag = false;
            RuleExpressionCondition condition = obj as RuleExpressionCondition;

            if (condition != null)
            {
                flag = (this.Name == condition.Name) && (((this._expression == null) && (condition.Expression == null)) || ((this._expression != null) && RuleExpressionWalker.Match(this._expression, condition.Expression)));
            }
            return(flag);
        }
        internal override RuleExpressionInfo Validate(CodeExpression expression, RuleValidation validation, bool isWritten)
        {
            ValidationError            error;
            CodeObjectCreateExpression newParent = (CodeObjectCreateExpression)expression;

            if (isWritten)
            {
                error = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CannotWriteToExpression, new object[] { typeof(CodeObjectCreateExpression).ToString() }), 0x17a);
                error.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(error);
                return(null);
            }
            if (newParent.CreateType == null)
            {
                error = new ValidationError(Messages.NullTypeType, 0x53d);
                error.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(error);
                return(null);
            }
            Type type = validation.ResolveType(newParent.CreateType);

            if (type == null)
            {
                return(null);
            }
            List <CodeExpression> argumentExprs = new List <CodeExpression>();

            try
            {
                if (!validation.PushParentExpression(newParent))
                {
                    return(null);
                }
                bool flag = false;
                for (int i = 0; i < newParent.Parameters.Count; i++)
                {
                    CodeExpression expression3 = newParent.Parameters[i];
                    if (expression3 == null)
                    {
                        error = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.NullConstructorParameter, new object[] { i.ToString(CultureInfo.CurrentCulture), RuleDecompiler.DecompileType(type) }), 0x53d);
                        error.UserData["ErrorObject"] = newParent;
                        validation.Errors.Add(error);
                        flag = true;
                    }
                    else
                    {
                        if (RuleExpressionWalker.Validate(validation, expression3, false) == null)
                        {
                            flag = true;
                        }
                        argumentExprs.Add(expression3);
                    }
                }
                if (flag)
                {
                    return(null);
                }
            }
            finally
            {
                validation.PopParentExpression();
            }
            BindingFlags constructorBindingFlags = BindingFlags.Public | BindingFlags.Instance;

            if (validation.AllowInternalMembers(type))
            {
                constructorBindingFlags |= BindingFlags.NonPublic;
            }
            if (type.IsValueType && (argumentExprs.Count == 0))
            {
                return(new RuleExpressionInfo(type));
            }
            if (type.IsAbstract)
            {
                error = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.UnknownConstructor, new object[] { RuleDecompiler.DecompileType(type) }), 0x137);
                error.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(error);
                return(null);
            }
            RuleConstructorExpressionInfo info2 = validation.ResolveConstructor(type, constructorBindingFlags, argumentExprs, out error);

            if (info2 == null)
            {
                error = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.UnknownConstructor, new object[] { RuleDecompiler.DecompileType(type) }), 0x137);
                error.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(error);
                return(null);
            }
            return(info2);
        }
        internal override RuleExpressionResult Evaluate(CodeExpression expression, RuleExecution execution)
        {
            CodeDirectionExpression expression2 = (CodeDirectionExpression)expression;

            return(RuleExpressionWalker.Evaluate(execution, expression2.Expression));
        }
        internal override RuleExpressionResult Evaluate(CodeExpression expression, RuleExecution execution)
        {
            object obj2;
            CodeObjectCreateExpression expression2 = (CodeObjectCreateExpression)expression;

            if (expression2.CreateType == null)
            {
                RuleEvaluationException exception = new RuleEvaluationException(Messages.NullTypeType);
                exception.Data["ErrorObject"] = expression2;
                throw exception;
            }
            RuleExpressionInfo info = execution.Validation.ExpressionInfo(expression2);

            if (info == null)
            {
                InvalidOperationException exception2 = new InvalidOperationException(Messages.ExpressionNotValidated);
                exception2.Data["ErrorObject"] = expression2;
                throw exception2;
            }
            RuleConstructorExpressionInfo info2 = info as RuleConstructorExpressionInfo;

            if (info2 == null)
            {
                return(new RuleLiteralResult(Activator.CreateInstance(info.ExpressionType)));
            }
            ConstructorInfo constructorInfo = info2.ConstructorInfo;

            object[] parameters = null;
            RuleExpressionResult[] resultArray = null;
            if ((expression2.Parameters != null) && (expression2.Parameters.Count > 0))
            {
                int             count     = expression2.Parameters.Count;
                ParameterInfo[] infoArray = constructorInfo.GetParameters();
                parameters = new object[infoArray.Length];
                int length = infoArray.Length;
                if (info2.NeedsParamsExpansion)
                {
                    length--;
                }
                int index = 0;
                while (index < length)
                {
                    Type expressionType                 = execution.Validation.ExpressionInfo(expression2.Parameters[index]).ExpressionType;
                    RuleExpressionResult    result      = RuleExpressionWalker.Evaluate(execution, expression2.Parameters[index]);
                    CodeDirectionExpression expression3 = expression2.Parameters[index] as CodeDirectionExpression;
                    if ((expression3 != null) && ((expression3.Direction == FieldDirection.Ref) || (expression3.Direction == FieldDirection.Out)))
                    {
                        if (resultArray == null)
                        {
                            resultArray = new RuleExpressionResult[count];
                        }
                        resultArray[index] = result;
                    }
                    parameters[index] = Executor.AdjustType(expressionType, result.Value, infoArray[index].ParameterType);
                    index++;
                }
                if (length < count)
                {
                    ParameterInfo info4       = infoArray[length];
                    Type          elementType = info4.ParameterType.GetElementType();
                    Array         array       = Array.CreateInstance(elementType, (int)(count - index));
                    while (index < count)
                    {
                        Type operandType             = execution.Validation.ExpressionInfo(expression2.Parameters[index]).ExpressionType;
                        RuleExpressionResult result2 = RuleExpressionWalker.Evaluate(execution, expression2.Parameters[index]);
                        array.SetValue(Executor.AdjustType(operandType, result2.Value, elementType), (int)(index - length));
                        index++;
                    }
                    parameters[length] = array;
                }
            }
            try
            {
                obj2 = constructorInfo.Invoke(parameters);
            }
            catch (TargetInvocationException exception3)
            {
                if (exception3.InnerException == null)
                {
                    throw;
                }
                throw new TargetInvocationException(string.Format(CultureInfo.CurrentCulture, Messages.Error_ConstructorInvoke, new object[] { RuleDecompiler.DecompileType(info2.ExpressionType), exception3.InnerException.Message }), exception3.InnerException);
            }
            if (resultArray != null)
            {
                for (int i = 0; i < expression2.Parameters.Count; i++)
                {
                    if (resultArray[i] != null)
                    {
                        resultArray[i].Value = parameters[i];
                    }
                }
            }
            return(new RuleLiteralResult(obj2));
        }
        internal void AnalyzeReadWrite(RuleAnalysis analysis, CodeExpression targetExpression, RulePathQualifier targetQualifier, CodeExpressionCollection argumentExpressions, ParameterInfo[] parameters, List <CodeExpression> attributedExpressions)
        {
            if (string.IsNullOrEmpty(attributePath))
            {
                // If the suffix is null or empty, this means the RuleAttributeTarget has no dependencies.
                if (attributeTarget == RuleAttributeTarget.This)
                {
                    // The target object has no dependencies.
                    attributedExpressions.Add(targetExpression);
                }
                else if (attributeTarget == RuleAttributeTarget.Parameter)
                {
                    // ALL arguments have no dependencies.
                    for (int i = 0; i < argumentExpressions.Count; ++i)
                    {
                        attributedExpressions.Add(argumentExpressions[i]);
                    }
                }
            }
            else
            {
                string suffix = attributePath;

                bool isRead  = !analysis.ForWrites;
                bool isWrite = analysis.ForWrites;

                if (attributeTarget == RuleAttributeTarget.This)
                {
                    // Target is "This", so perform the analysis on the target expression.

                    // Remove the optional "this/" token if present.
                    string optionalPrefix = "this/";
                    if (suffix.StartsWith(optionalPrefix, StringComparison.Ordinal))
                    {
                        suffix = suffix.Substring(optionalPrefix.Length);
                    }

                    RuleExpressionWalker.AnalyzeUsage(analysis, targetExpression, isRead, isWrite, new RulePathQualifier(suffix, targetQualifier));
                    attributedExpressions.Add(targetExpression);
                }
                else if (attributeTarget == RuleAttributeTarget.Parameter)
                {
                    string paramName = null;

                    int firstSlash = suffix.IndexOf('/');
                    if (firstSlash >= 0)
                    {
                        paramName = suffix.Substring(0, firstSlash);
                        suffix    = suffix.Substring(firstSlash + 1);
                    }
                    else
                    {
                        paramName = suffix;
                        suffix    = null;
                    }

                    // Find the ParameterInfo that corresponds to this attribute path.
                    ParameterInfo param = Array.Find <ParameterInfo>(parameters,
                                                                     delegate(ParameterInfo p) { return(p.Name == paramName); });
                    if (param != null)
                    {
                        RulePathQualifier qualifier = string.IsNullOrEmpty(suffix) ? null : new RulePathQualifier(suffix, null);

                        // 99.9% of the time, the parameter usage attribute only applies to one argument.  However,
                        // if this attribute corresponds to the last parameter, then just assume that all the trailing
                        // arguments correspond.  (In other words, if the caller passed more arguments then there
                        // are parameters, we assume it was a params array.)
                        //
                        // Usually this loop will only execute once.
                        int end = param.Position + 1;
                        if (param.Position == parameters.Length - 1)
                        {
                            end = argumentExpressions.Count;
                        }

                        for (int i = param.Position; i < end; ++i)
                        {
                            CodeExpression argExpr = argumentExpressions[i];
                            RuleExpressionWalker.AnalyzeUsage(analysis, argExpr, isRead, isWrite, qualifier);
                            attributedExpressions.Add(argExpr);
                        }
                    }
                }
            }
        }
예제 #24
0
        internal override RuleExpressionInfo Validate(CodeExpression expression, RuleValidation validation, bool isWritten)
        {
            ValidationError            item = null;
            RulePropertyExpressionInfo info = null;
            bool nonPublic                     = false;
            Type expressionType                = null;
            CodeIndexerExpression newParent    = (CodeIndexerExpression)expression;
            CodeExpression        targetObject = newParent.TargetObject;

            if (targetObject == null)
            {
                item = new ValidationError(Messages.NullIndexerTarget, 0x53d);
                item.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(item);
                return(null);
            }
            if (targetObject is CodeTypeReferenceExpression)
            {
                item = new ValidationError(Messages.IndexersCannotBeStatic, 0x53d);
                item.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(item);
                return(null);
            }
            if ((newParent.Indices == null) || (newParent.Indices.Count == 0))
            {
                item = new ValidationError(Messages.MissingIndexExpressions, 0x53d);
                item.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(item);
                return(null);
            }
            try
            {
                if (!validation.PushParentExpression(newParent))
                {
                    return(null);
                }
                RuleExpressionInfo info2 = RuleExpressionWalker.Validate(validation, newParent.TargetObject, false);
                if (info2 == null)
                {
                    return(null);
                }
                expressionType = info2.ExpressionType;
                if (expressionType == null)
                {
                    return(null);
                }
                if (expressionType == typeof(NullLiteral))
                {
                    item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.NullIndexerTarget, new object[0]), 0x53d);
                    item.UserData["ErrorObject"] = newParent;
                    validation.Errors.Add(item);
                    expressionType = null;
                }
                List <CodeExpression> argumentExprs = new List <CodeExpression>();
                bool flag2 = false;
                for (int i = 0; i < newParent.Indices.Count; i++)
                {
                    CodeExpression expression4 = newParent.Indices[i];
                    if (expression4 == null)
                    {
                        item = new ValidationError(Messages.NullIndexExpression, 0x53d);
                        item.UserData["ErrorObject"] = newParent;
                        validation.Errors.Add(item);
                        flag2 = true;
                    }
                    else
                    {
                        CodeDirectionExpression expression5 = expression4 as CodeDirectionExpression;
                        if ((expression5 != null) && (expression5.Direction != FieldDirection.In))
                        {
                            item = new ValidationError(Messages.IndexerArgCannotBeRefOrOut, 0x19d);
                            item.UserData["ErrorObject"] = newParent;
                            validation.Errors.Add(item);
                            flag2 = true;
                        }
                        if (expression4 is CodeTypeReferenceExpression)
                        {
                            item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CodeExpressionNotHandled, new object[] { expression4.GetType().FullName }), 0x548);
                            item.UserData["ErrorObject"] = expression4;
                            validation.AddError(item);
                            flag2 = true;
                        }
                        if (RuleExpressionWalker.Validate(validation, expression4, false) == null)
                        {
                            flag2 = true;
                        }
                        else
                        {
                            argumentExprs.Add(expression4);
                        }
                    }
                }
                if (expressionType == null)
                {
                    return(null);
                }
                if (flag2)
                {
                    return(null);
                }
                BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.Instance;
                if (validation.AllowInternalMembers(expressionType))
                {
                    bindingFlags |= BindingFlags.NonPublic;
                    nonPublic     = true;
                }
                info = validation.ResolveIndexerProperty(expressionType, bindingFlags, argumentExprs, out item);
                if (info == null)
                {
                    item.UserData["ErrorObject"] = newParent;
                    validation.Errors.Add(item);
                    return(null);
                }
            }
            finally
            {
                validation.PopParentExpression();
            }
            PropertyInfo propertyInfo   = info.PropertyInfo;
            MethodInfo   accessorMethod = isWritten ? propertyInfo.GetSetMethod(nonPublic) : propertyInfo.GetGetMethod(nonPublic);

            if (accessorMethod == null)
            {
                string format = isWritten ? Messages.UnknownPropertySet : Messages.UnknownPropertyGet;
                item = new ValidationError(string.Format(CultureInfo.CurrentCulture, format, new object[] { propertyInfo.Name, RuleDecompiler.DecompileType(expressionType) }), 0x54a);
                item.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(item);
                return(null);
            }
            if (!validation.ValidateMemberAccess(targetObject, expressionType, accessorMethod, propertyInfo.Name, newParent))
            {
                return(null);
            }
            object[] customAttributes = propertyInfo.GetCustomAttributes(typeof(RuleAttribute), true);
            if ((customAttributes != null) && (customAttributes.Length > 0))
            {
                Stack <MemberInfo> stack = new Stack <MemberInfo>();
                stack.Push(propertyInfo);
                bool flag3 = true;
                foreach (RuleAttribute attribute in customAttributes)
                {
                    if (!attribute.Validate(validation, propertyInfo, expressionType, propertyInfo.GetIndexParameters()))
                    {
                        flag3 = false;
                    }
                }
                stack.Pop();
                if (!flag3)
                {
                    return(null);
                }
            }
            return(info);
        }