public CodeMethodReferenceExpression(CodeExpression targetObject,
string methodName, params CodeTypeReference[] typeParameters) :
this (targetObject, methodName)
{
if (typeParameters != null && typeParameters.Length > 0)
TypeArguments.AddRange(typeParameters);
}
public CodeMethodInvokeExpression(CodeExpression targetObject,
string methodName,
params CodeExpression[] parameters)
{
this.method = new CodeMethodReferenceExpression(targetObject, methodName);
this.Parameters.AddRange(parameters);
}
protected override void GenerateDefaultArgMethod(
CodeParameterDeclarationExpression[] argList,
CodeExpression [] paramList)
{
var cons = gen.Constructor(argList, () => {});
cons.ChainedConstructorArgs.AddRange(paramList);
}
public CodeForStatement(CodeExpression init, CodeExpression condition,CodeExpression next, CodeStatement statement)
{
Init = init;
Condition = condition;
Next = next;
Statement = statement;
}
public CodeIterationStatement(CodeStatement initStatement, CodeExpression testExpression, CodeStatement incrementStatement, params CodeStatement[] statements)
{
InitStatement = initStatement;
TestExpression = testExpression;
IncrementStatement = incrementStatement;
Statements.AddRange(statements);
}
public static CodeExpression WrapInCast(CodeExpression srcExpr, byte sizeInBits, bool forceCastOnLiteral = false)
{
CodeTypeReference tp = null;
if (sizeInBits <= 8)
tp = StaticTypeReferences.Byte;
else if (sizeInBits <= 16)
tp = StaticTypeReferences.UShort;
else if (sizeInBits <= 32)
tp = StaticTypeReferences.UInt;
else if (sizeInBits <= 64)
tp = StaticTypeReferences.ULong;
else
throw new Exception("Geeze, that's giant!");
if (srcExpr is CodeCastExpression)
{
if (((CodeCastExpression)srcExpr).TargetType != tp)
((CodeCastExpression)srcExpr).TargetType = tp;
return srcExpr;
}
// This is only valid because of the
// context in which this method is called.
// (aka. this call is used only to widen
// values, it is never used to make them
// smaller)
else if (!forceCastOnLiteral && srcExpr is CodePrimitiveExpression)
{
return srcExpr;
}
return new CodeCastExpression(tp, srcExpr);
}
public CodeBinaryOperatorExpression(CodeExpression left,
CodeBinaryOperatorType op,
CodeExpression right)
{
this.left = left;
this.op = op;
this.right = right;
}
public CodeVariableDeclarationStatement(string type,
string name,
CodeExpression initExpression)
{
this.type = new CodeTypeReference(type);
this.name = name;
this.initExpression = initExpression;
}
public CodeConditionStatement(CodeExpression condition,
CodeStatement[] trueStatements,
CodeStatement[] falseStatements)
{
this.condition = condition;
this.TrueStatements.AddRange(trueStatements);
this.FalseStatements.AddRange(falseStatements);
}
public CodeMethodReferenceExpression(CodeExpression targetObject, string methodName, params CodeTypeReference[] typeParameters)
{
TargetObject = targetObject;
MethodName = methodName;
if (typeParameters != null && typeParameters.Length > 0)
{
TypeArguments.AddRange(typeParameters);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="T:System.Windows.Forms.Form"/> class.
/// </summary>
/// <remarks></remarks>
public CodeView(CodeExpression<Proband> code)
{
InitializeComponent();
Code = code;
if (code != null)
{
string rtf = RenderToRtf(code);
richTextBoxCode.Rtf = rtf;
}
}
public void AddRange(CodeExpression[] value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
for (int i = 0; i < value.Length; i++)
{
Add(value[i]);
}
}
public void Ctor(string name, CodeExpression value)
{
if (string.IsNullOrEmpty(name))
{
var argument1 = new CodeAttributeArgument(value);
Assert.Empty(argument1.Name);
Assert.Equal(value, argument1.Value);
}
var argument2 = new CodeAttributeArgument(name, value);
Assert.Equal(name ?? string.Empty, argument2.Name);
Assert.Equal(value, argument2.Value);
}
/// <summary>
/// Rendert den Code als Rich Text
/// </summary>
/// <param name="code">Der Code</param>
/// <returns></returns>
private string RenderToRtf(CodeExpression<Proband> code)
{
StringBuilder builder = new StringBuilder();
builder.AppendLine(@"{\rtf1\ansi\deff0");
// crimson --> #DC143C
// dodger --> #1E90FF
builder.AppendLine(@"{\colortbl;\red255\green255\blue255;\red220\green20\blue60;\red30\green144\blue255;}");
builder.AppendLine(@"{\fonttbl\f0\fswiss Consolas;}\f0\cf1");
RenderToRtf(code, 0, builder);
builder.AppendLine("}");
return builder.ToString();
}
public override CodeExpression GetPaddedHexToString(CodeExpression obj, int padSize)
{
return new CodeBinaryOperatorExpression(
new CodePrimitiveExpression("0x"),
CodeBinaryOperatorType.StringConcat,
new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression()
{
MethodName = "format"
},
new CodePrimitiveExpression("%0" + padSize.ToString() + "X"),
obj
)
);
}
public override CodeExpression GetCodeExpression(
BoundPropertyEntry entry, object parsedData,
ExpressionBuilderContext context)
{
// entry.Expression is the number string
// (minus the RandomNumber: prefix).
if (!entry.Expression.Contains(","))
{
throw new ArgumentException("Must include two numbers separated by a comma.");
}
else
{
// Get the two numbers.
string[] numbers = entry.Expression.Split(',');
if (numbers.Length != 2)
{
throw new ArgumentException("Only include two numbers.");
}
else
{
int lowerLimit, upperLimit;
if (Int32.TryParse(numbers[0], out lowerLimit) &&
Int32.TryParse(numbers[1], out upperLimit))
{
// So far all the operations have been performed in
// normal code. That's because the two numbers are
// specified in the expression, and so they won't
// change each time the page is requested.
// However, the random number should be allowed to
// change each time, so you need to switch to CodeDOM.
Type type = entry.DeclaringType;
PropertyDescriptor descriptor = TypeDescriptor.GetProperties(type)[entry.PropertyInfo.Name];
CodeExpression[] expressionArray = new CodeExpression[2];
expressionArray[0] = new CodePrimitiveExpression(lowerLimit);
expressionArray[1] = new CodePrimitiveExpression(upperLimit);
return new CodeCastExpression(descriptor.PropertyType, new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(base.GetType()), "GetRandomNumber", expressionArray));
}
else
{
throw new ArgumentException("Use valid integers.");
}
}
}
}
public override CodeExpression GetCodeExpression(BoundPropertyEntry entry,
object parsedData, ExpressionBuilderContext context)
{
// entry.Expression - строка с числом
// без префикса (например: "1,6").
if (!entry.Expression.Contains(","))
{
throw new ArgumentException(" Должны быть указаны два числа, разделенные запятой");
}
else
{
// Получить два числа
string[] numbers = entry.Expression.Split(',');
if (numbers.Length != 2)
{
throw new ArgumentException("Должны быть указаны два числа");
}
else
{
int min, max;
if (Int32.TryParse(numbers[0], out min) &&
Int32.TryParse(numbers[1], out max))
{
// Получить ссылку на класс, имеющий метод GetRandomNumber().
// (Это класс, где данный код выполняется.)
CodeTypeReferenceExpression typeRef = new CodeTypeReferenceExpression(this.GetType());
// Определить параметры для GetRandomNumber().
CodeExpression[] methodParameters = new CodeExpression[2];
methodParameters[0] = new CodePrimitiveExpression(min);
methodParameters[1] = new CodePrimitiveExpression(max);
// Вернуть выражение привязки вызвав метод GetRandomNumber()
CodeMethodInvokeExpression methodCall = new CodeMethodInvokeExpression(
typeRef, "GetRandomNumber", methodParameters);
return methodCall;
}
else
{
throw new ArgumentException("Должны использоваться допустимые целые числа");
}
}
}
}
public virtual CodeExpression GetPaddedHexToString(CodeExpression obj, int padSize)
{
return new CodeBinaryOperatorExpression(
new CodePrimitiveExpression("0x"),
CodeBinaryOperatorType.StringConcat,
new CodeMethodInvokeExpression(
new CodeMethodInvokeExpression(
obj,
"ToString",
new CodePrimitiveExpression("X")
),
"PadLeft",
new CodePrimitiveExpression(padSize),
new CodePrimitiveExpression('0')
)
);
}
public CodeExpression GetExpression(CodeExpression src)
{
CodeExpression baseExpression = new CodeBinaryOperatorExpression(
src,
CodeBinaryOperatorType.BitwiseAnd,
new CodePrimitiveExpression((uint)(((1u << (byte)(EndIdx - StartIdx + 1)) - 1) << (byte)StartIdx))
);
if (StartIdx != 0)
{
baseExpression = new CodeBinaryOperatorExpression(
baseExpression,
CodeBinaryOperatorType.ShiftRight,
new CodePrimitiveExpression((int)StartIdx)
);
}
return Utils.WrapInCast(
baseExpression,
(byte)Length
);
}
public override CodeExpression GetCodeExpression(System.Web.UI.BoundPropertyEntry entry, object parsedData, ExpressionBuilderContext context)
{
if (!entry.Expression.Contains(","))
{
throw new ArgumentException(
"Must include two numbers separated by a comma.");
}
else
{
// Get the two numbers.
string[] numbers = entry.Expression.Split(',');
if (numbers.Length != 2)
{
throw new ArgumentException("Only include two numbers.");
}
else
{
int lowerLimit, upperLimit;
if (Int32.TryParse(numbers[0], out lowerLimit) &&
Int32.TryParse(numbers[1], out upperLimit))
{
// Get a reference to the class that has the
// GetRandomNumber() method.
// (It's the class where this code is executing.)
CodeTypeReferenceExpression typeRef = new
CodeTypeReferenceExpression(this.GetType());
CodeExpression[] methodParameters = new CodeExpression[2];
methodParameters[0] = new CodePrimitiveExpression(lowerLimit);
methodParameters[1] = new CodePrimitiveExpression(upperLimit);
return new CodeMethodInvokeExpression(typeRef, "GetRandomNumber", methodParameters);
}
else
{
throw new ArgumentException("Use valid integers.");
}
}
}
}
private CodeMethodInvokeExpression CreateConversionExpressionJ2CParam(GType paramType, CodeExpression invokeExpression)
{
return(CEEJ2C(paramType, invokeExpression, true));
}
public virtual object Serialize(IDesignerSerializationManager manager, object value)
{
object obj2 = null;
if ((manager == null) || (value == null))
{
throw new ArgumentNullException((manager == null) ? "manager" : "value");
}
using (CodeDomSerializerBase.TraceScope("CodeDomSerializer::Serialize"))
{
bool flag2;
bool flag3;
if (value is Type)
{
return(new CodeTypeOfExpression((Type)value));
}
bool flag = false;
CodeExpression expression = base.SerializeCreationExpression(manager, value, out flag2);
if (!(value is IComponent))
{
flag = flag2;
}
ExpressionContext context = manager.Context[typeof(ExpressionContext)] as ExpressionContext;
if ((context != null) && object.ReferenceEquals(context.PresetValue, value))
{
flag3 = true;
}
else
{
flag3 = false;
}
if (expression == null)
{
return(obj2);
}
if (flag)
{
return(expression);
}
CodeStatementCollection statements = new CodeStatementCollection();
if (flag3)
{
base.SetExpression(manager, value, expression, true);
}
else
{
string uniqueName = base.GetUniqueName(manager, value);
CodeVariableDeclarationStatement statement = new CodeVariableDeclarationStatement(TypeDescriptor.GetClassName(value), uniqueName)
{
InitExpression = expression
};
statements.Add(statement);
CodeExpression expression2 = new CodeVariableReferenceExpression(uniqueName);
base.SetExpression(manager, value, expression2);
}
base.SerializePropertiesToResources(manager, statements, value, _designTimeFilter);
base.SerializeProperties(manager, statements, value, _runTimeFilter);
base.SerializeEvents(manager, statements, value, _runTimeFilter);
return(statements);
}
}
public static CodePropertyReferenceExpression Property(this CodeExpression expr, string name)
{
return(new CodePropertyReferenceExpression(expr, name));
}
public CodeMethodReferenceExpression GetMarshalMethod(CodeExpression target)
{
return(new CodeMethodReferenceExpression(target, MarshalMethod));
}
/// <summary>
/// Invoke a method on target as statement.
/// </summary>
public CodeExpressionStatement InvokeMethod(CodeExpression target, string name, params CodeExpression[] arguments)
{
return(Add(new CodeMethodInvokeExpression(target, name, arguments)));
}
CodeExpression?Translate_isinstance(Application appl, CodeExpression[] args)
{
if (appl.args.Count != 2)
{
return(null);
}
List <Exp> types;
if (appl.args[1].defval is PyTuple tuple)
{
types = tuple.values.ToList();
}
else
{
types = new List <Exp> {
appl.args[1].defval !
};
}
var exp = appl.args[0].defval !.Accept(expTranslator);
return(types.
Select(t => m.BinOp(
exp,
CodeOperatorType.Is,
m.TypeRefExpr(t.ToString())))
.Aggregate((a, b) => m.BinOp(a, CodeOperatorType.LogOr, b)));
}
CodeExpression Translate_int(Application appl, CodeExpression[] args)
{
m.EnsureImport("System");
var fn = m.MethodRef(m.TypeRefExpr("Convert"), "ToInt32");
return(m.Appl(fn, args));
}
CodeExpression?Translate_list(Application appl, CodeExpression[] args)
{
if (args.Length == 0)
{
m.EnsureImport("System.Collections.Generic");
return(m.New(m.TypeRef("List", "object")));
}
if (args.Length == 1)
{
m.EnsureImport("System.Linq");
var fn = m.MethodRef(args[0], "ToList");
return(m.Appl(fn));
}
return(null);
}
CodeExpression?Translate_set(Application appl, CodeExpression[] args)
{
if (args.Length == 0 || args.Length == 1)
{
m.EnsureImport("System.Collections.Generic");
return(m.New(
m.TypeRef("HashSet", "object"),
args));
}
return(null);
}
CodeExpression?Translate_dict(Application appl, CodeExpression[] args)
{
if (args.Length == 0)
{
m.EnsureImport("System.Collections.Generic");
return(m.New(
m.TypeRef("Dictionary", "object", "object")));
}
else if (args.All(a => a is CodeNamedArgument))
{
m.EnsureImport("System.Collections.Generic");
var exp = m.New(
m.TypeRef("Dictionary", "string", "object"));
exp.Initializer = new CodeCollectionInitializer(
args.Cast <CodeNamedArgument>()
.Select(a =>
new CodeCollectionInitializer(
m.Prim(
((CodeVariableReferenceExpression)a.exp1).Name),
a.exp2 !))
.ToArray());
return(exp);
}
else if (args.Length == 1)
{
m.EnsureImport("System.Collections.Generic");
return(m.Appl(m.MethodRef(args[0], "ToDictionary")));
}
return(null);
}
CodeExpression?Translate_len(Application appl, CodeExpression[] args)
{
if (args.Length == 1)
{
var arg = args[0];
//$TODO: if args is known to be an iterable, but not a collection,
// using LinQ Count() instead?
return(m.Access(arg, "Count"));
}
return(null);
}
CodeExpression?Translate_sum(Application appl, CodeExpression[] args)
{
if (args.Length == 1)
{
m.EnsureImport("System.Linq");
var arg = args[0];
args = new CodeExpression[0];
var fn = m.Access(arg, "Sum");
return(m.Appl(fn, args));
}
return(null);
}
CodeExpression?Translate_range(Application appl, CodeExpression[] args)
{
var argsCount = args.Length;
if (1 <= argsCount && argsCount <= 3)
{
m.EnsureImport("System");
m.EnsureImport("System.Linq");
var enumerableRange = m.MethodRef(m.TypeRefExpr("Enumerable"), "Range");
var mathCeiling = m.MethodRef(m.TypeRefExpr("Math"), "Ceiling");
var convertToInt32 = m.MethodRef(m.TypeRefExpr("Convert"), "ToInt32");
var convertToDouble = m.MethodRef(m.TypeRefExpr("Convert"), "ToDouble");
switch (argsCount)
{
case 1:
{
// Enumerable.Range(0, count);
var startExp = m.Prim(0);
var countExp = args[0];
return(m.Appl(enumerableRange, startExp, countExp));
}
case 2:
{
// Enumerable.Range(0, count);
var startExp = args[0];
var stopExp = args[1];
var countExp = m.Sub(stopExp, startExp);
return(m.Appl(enumerableRange, startExp, countExp));
}
case 3:
{
// Enumerable.Range(0, count).Select(x => start + x * step);
var startExp = args[0];
var stopExp = args[1];
var stepExp = args[2];
// count = (stop - start) divide_ceiling_by step;
var rawCountExp = m.Sub(stopExp, startExp);
var rawDoubleCountExp = m.Appl(convertToDouble, rawCountExp);
var countDividedExp = m.Div(rawDoubleCountExp, stepExp);
var countCeilingExp = m.Appl(mathCeiling, countDividedExp);
var countExp = m.Appl(convertToInt32, countCeilingExp);
// Enumerable.Range(0, count);
var rangeExp = m.Appl(enumerableRange, m.Prim(0), countExp);
// x => start + x * step;
var lambdaArgExp = expTranslator.gensym.GenSymLocal("_x_", m.TypeRef("object"));
var offsetExp = m.Mul(lambdaArgExp, stepExp);
var positionExp = m.Add(startExp, offsetExp);
var mapLambdaExp = new CodeLambdaExpression(new CodeExpression[] { lambdaArgExp }, positionExp);
var selectExt = m.Access(rangeExp, "Select");
return(m.Appl(selectExt, mapLambdaExp));
}
}
}
return(null);
}
CodeExpression?Translate_filter(Application appl, CodeExpression[] args)
{
if (args.Length == 2)
{
m.EnsureImport("System.Collections.Generic");
m.EnsureImport("System.Linq");
var filter = args[0];
if (appl.args[0].defval is NoneExp)
{
var formal = expTranslator.gensym.GenSymLocal("_p_", m.TypeRef("object"));
filter = m.Lambda(
new[] { formal },
m.BinOp(formal, CodeOperatorType.NotEqual, m.Prim(null)));
}
var fn = m.MethodRef(
m.Appl(m.MethodRef(args[1], "Where"), filter),
"ToList");
args = new CodeExpression[0];
return(m.Appl(fn, args));
}
return(null);
}
CodeExpression?Translate_complex(Application appl, CodeExpression[] args)
{
if (args.Length == 2)
{
m.EnsureImport("System.Numerics");
return(m.New(m.TypeRef("Complex"), args));
}
return(null);
}
CodeExpression?Translate_float(Application appl, CodeExpression[] args)
{
if (args[0] is CodePrimitiveExpression c && c.Value is Str str)
{
switch (str.s)
{
case "inf":
case "+inf":
case "Infinity":
case "+Infinity":
return(m.Access(m.TypeRefExpr("double"), "PositiveInfinity"));
case "-inf":
case "-Infinity":
return(m.Access(m.TypeRefExpr("double"), "NegativeInfinity"));
}
}
return(null);
}
CodeExpression Translate_sorted(Application appl, CodeExpression[] args)
{
if (args.Length == 0)
{
return(m.Appl(new CodeVariableReferenceExpression("sorted"), args));
}
var iter = args[0];
var cmp = args.Length > 1 && !(args[1] is CodeNamedArgument)
? args[1]
: null;
var key = args.Length > 2 && !(args[2] is CodeNamedArgument)
? args[2]
: null;
var rev = args.Length > 3 && !(args[3] is CodeNamedArgument)
? args[3]
: null;
var namedArgs = args.OfType <CodeNamedArgument>().ToDictionary(
k => ((CodeVariableReferenceExpression)k.exp1).Name,
v => v.exp2);
if (namedArgs.TryGetValue("cmp", out var tmp))
{
cmp = tmp;
}
if (namedArgs.TryGetValue("key", out tmp))
{
key = tmp;
}
if (namedArgs.TryGetValue("reverse", out tmp))
{
rev = tmp;
}
m.EnsureImport("System.Collections.Generic");
var formal = expTranslator.gensym.GenSymLocal("_p_", m.TypeRef("object"));
return(m.ApplyMethod(
m.ApplyMethod(
iter,
IsReverse(rev) ? "OrderByDescending" : "OrderBy",
cmp ?? key ?? m.Lambda(new[] { formal }, formal)),
"ToList"));
}
CodeExpression Translate_str(Application appl, CodeExpression[] args)
{
switch (args.Length)
{
case 1:
return(m.ApplyMethod(args[0], "ToString"));
case 2:
case 3:
//$TODO: careless about the third arg here.
m.EnsureImport("System.Text");
var getEncoding = m.ApplyMethod(
m.TypeRefExpr("Encoding"),
"GetEncoding",
args[1]);
return(m.ApplyMethod(getEncoding, "GetString", args[0]));
default:
throw new NotImplementedException($"str({string.Join<CodeExpression>(",", args)})");
}
}
public RpcMarshalArgument(CodeExpression expression, CodeTypeReference code_type)
{
Expression = expression;
CodeType = code_type;
}
static CodeBinaryOperatorExpression IsFalse(CodeExpression expr)
{
return(new CodeBinaryOperatorExpression(expr, CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(false)));
}
internal protected override void GenerateBuildCode(GeneratorContext ctx, CodeExpression var)
{
if (!String.IsNullOrEmpty(UIManagerName))
{
// Create an UI manager
CodeFieldReferenceExpression uixp = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), UIManagerName);
CodeAssignStatement uim_init = new CodeAssignStatement(uixp, new CodeObjectCreateExpression(typeof(Gtk.UIManager).ToGlobalTypeRef()));
ctx.Statements.Add(uim_init);
includedActionGroups = new ArrayList();
// Generate action group creation
foreach (ActionGroup actionGroup in actionGroups)
{
// Create the action group
string grpVar = ctx.NewId();
CodeVariableDeclarationStatement uidec = new CodeVariableDeclarationStatement(
typeof(Gtk.ActionGroup).ToGlobalTypeRef(),
grpVar,
actionGroup.GenerateObjectCreation(ctx)
);
ctx.Statements.Add(uidec);
actionGroup.GenerateBuildCode(ctx, new CodeVariableReferenceExpression(grpVar));
// Insert the action group in the UIManager
CodeMethodInvokeExpression mi = new CodeMethodInvokeExpression(
uixp,
"InsertActionGroup",
new CodeVariableReferenceExpression(grpVar),
new CodePrimitiveExpression(includedActionGroups.Count)
);
ctx.Statements.Add(mi);
includedActionGroups.Add(actionGroup);
}
// Adds the accel group to the window
Window w = GetTopLevel() as Window;
if (w != null)
{
CodeMethodInvokeExpression ami = new CodeMethodInvokeExpression(
ctx.WidgetMap.GetWidgetExp(w),
"AddAccelGroup",
new CodePropertyReferenceExpression(
uixp,
"AccelGroup"
)
);
ctx.Statements.Add(ami);
}
else
{
// There is no top level window, this must be a custom widget.
// The only option is to register the accel group when
// the widget is realized. This is done by the Bin wrapper.
}
}
if (tooltip != null && tooltip.Length > 0)
{
GetTopLevel().GenerateTooltip(ctx, this);
}
base.GenerateBuildCode(ctx, var);
}
/// <summary>
/// Serializes the given object into a CodeDom object.
/// </summary>
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeExpression expression = null;
using (TraceScope("EnumCodeDomSerializer::" + nameof(Serialize)))
{
Trace("Type: {0}", (value == null ? "(null)" : value.GetType().Name));
if (value is Enum)
{
bool needCast = false;
Enum[] values;
TypeConverter converter = TypeDescriptor.GetConverter(value);
if (converter != null && converter.CanConvertTo(typeof(Enum[])))
{
values = (Enum[])converter.ConvertTo(value, typeof(Enum[]));
needCast = (values.Length > 1);
}
else
{
values = new Enum[] { (Enum)value };
needCast = true;
}
// EnumConverter (and anything that is overridden to support enums)
// should be providing us a conversion to Enum[] for flag styles.
// If it doesn't, we will emit a warning and just do a cast from the enum value.
CodeTypeReferenceExpression enumType = new CodeTypeReferenceExpression(value.GetType());
// If names is of length 1, then this is a simple field reference. Otherwise,
// it is an or-d combination of expressions.
//
TraceIf(values.Length == 1, "Single field entity.");
TraceIf(values.Length > 1, "Multi field entity.");
// We now need to serialize the enum terms as fields. We new up an EnumConverter to do
// that. We cannot use the type's own converter since it might have a different string
// representation for its values. Hardcoding is okay in this case, since all we want is
// the enum's field name. Simply doing ToString() will not give us any validation.
TypeConverter enumConverter = new EnumConverter(value.GetType());
foreach (Enum term in values)
{
string termString = enumConverter?.ConvertToString(term);
CodeExpression newExpression = !String.IsNullOrEmpty(termString) ? new CodeFieldReferenceExpression(enumType, termString) : null;
if (newExpression != null)
{
if (expression == null)
{
expression = newExpression;
}
else
{
expression = new CodeBinaryOperatorExpression(expression, CodeBinaryOperatorType.BitwiseOr, newExpression);
}
}
}
// If we had to combine multiple names, wrap the result in an appropriate cast.
//
if (expression != null && needCast)
{
expression = new CodeCastExpression(value.GetType(), expression);
}
}
else
{
Debug.Fail("Enum serializer called for non-enum object.");
TraceError("Enum serializer called for non-enum object {0}", (value == null ? "(null)" : value.GetType().Name));
}
}
return(expression);
}
static CodeBinaryOperatorExpression NotNull(CodeExpression reference)
{
return(new CodeBinaryOperatorExpression(reference, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null)));
}
/// <summary>
/// Applies the given expression to the given code expressions as input
/// </summary>
/// <typeparam name="T1">The type of the first argument</typeparam>
/// <typeparam name="T2">The type of the second argument</typeparam>
/// <typeparam name="T3">The type of the third argument</typeparam>
/// <typeparam name="T4">The type of the fourth argument</typeparam>
/// <typeparam name="TResult">The type of the result</typeparam>
/// <param name="expression">The expression to be converted to CodeDOM</param>
/// <param name="argument1">The first argument</param>
/// <param name="argument2">The second argument</param>
/// <param name="argument3">The third argument</param>
/// <param name="argument4">The fourth argument</param>
/// <returns>The CodeDOM expression that contains the equivalent code</returns>
public static CodeExpression ApplyExpression <T1, T2, T3, T4, TResult>(Expression <Func <T1, T2, T3, T4, TResult> > expression, CodeExpression argument1, CodeExpression argument2, CodeExpression argument3, CodeExpression argument4)
{
if (expression == null)
{
throw new ArgumentNullException("expression");
}
var dict = new Dictionary <Expression, CodeExpression>();
dict.Add(expression.Parameters[0], argument1);
dict.Add(expression.Parameters[1], argument2);
dict.Add(expression.Parameters[2], argument3);
dict.Add(expression.Parameters[3], argument4);
return(ApplyExpression(expression.Body, dict));
}
/// <summary>
/// Creates a backing field for the given property
/// </summary>
/// <param name="property">The code property</param>
/// <param name="type">The type of the property</param>
/// <param name="initialValue">The initial value expression for the field</param>
/// <returns>A reference to the generated backing field</returns>
public static CodeFieldReferenceExpression CreateBackingField(this CodeMemberProperty property, CodeTypeReference type, CodeExpression initialValue)
{
var reference = CodeDomHelper.GetOrCreateUserItem <CodeFieldReferenceExpression>(property, CodeDomHelper.BackingFieldKey);
if (reference == null)
{
var field = new CodeMemberField()
{
Attributes = MemberAttributes.Private,
Name = "_" + property.Name.ToCamelCase(),
Type = type ?? new CodeTypeReference(typeof(object))
};
field.AddAttribute(typeof(DebuggerBrowsableAttribute), DebuggerBrowsableState.Never);
field.WriteDocumentation(string.Format("The backing field for the {0} property", property.Name));
property.DependentMembers(true).Add(field);
if (initialValue != null)
{
field.InitExpression = initialValue;
}
reference = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), field.Name);
CodeDomHelper.SetUserItem(property, CodeDomHelper.BackingFieldRefKey, reference);
CodeDomHelper.SetUserItem(property, CodeDomHelper.BackingFieldKey, field);
}
return(reference);
}
/// <summary>
/// Generates an OnChanged-pattern for the given property
/// </summary>
/// <param name="property">The code property</param>
/// <returns>The statement to call the OnChanged method for the given property</returns>
public static CodeStatement CreateOnChangedEventPattern(this CodeMemberProperty property, CodeTypeReference eventType, CodeExpression eventData)
{
CodeTypeReference handlerType;
if (eventType == null)
{
handlerType = typeof(EventHandler).ToTypeReference();
}
else
{
handlerType = typeof(EventHandler <>).ToTypeReference(eventType);
}
var changedEvent = new CodeMemberEvent()
{
Name = property.Name + "Changed",
Type = handlerType,
Attributes = MemberAttributes.Public | MemberAttributes.Final
};
changedEvent.WriteDocumentation(string.Format("Gets fired when the {0} property changed its value", property.Name));
if (eventType == null)
{
eventType = new CodeTypeReference(typeof(EventArgs).Name);
eventData = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(eventType), "Empty");
}
var onChanged = CodeDomHelper.CreateRaiseMethod(changedEvent, eventType);
var dependent = property.DependentMembers(true);
dependent.Add(onChanged);
dependent.Add(changedEvent);
var onChangedRef = new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), onChanged.Name);
return(new CodeExpressionStatement(new CodeMethodInvokeExpression(onChangedRef, eventData)));
}
private CodeMethodInvokeExpression CEEJ2C(GType paramType, CodeExpression invokeExpression, bool param)
{
CodeTypeReference[] par;
if (paramType.IsArray)
{
GType element = paramType.ArrayElement;
if (element.IsPrimitive)
{
par = new CodeTypeReference[] {};
return(CCE("ArrayPrimJ2C" + element.Name, par, invokeExpression, true));
}
if (element == Repository.javaLangString)
{
par = new CodeTypeReference[] {};
return(CCE("ArrayStrongJ2CpString", par, invokeExpression, true));
}
if (element == Repository.systemString)
{
par = new CodeTypeReference[] { };
return(CCE("ArrayStrongJ2CString", par, invokeExpression, true));
}
if (element == Repository.javaLangClass)
{
par = new CodeTypeReference[] {};
return(CCE("ArrayStrongJ2CpClass", par, invokeExpression, true));
}
if (!element.IsInterface && !element.IsCLRRootType && element.IsCLRRealType)
{
par = new[] { paramType.CLRReference, paramType.ArrayElement.CLRReference };
return(CCE("ArrayStrongJp2C", par, invokeExpression, true));
}
if (!element.IsInterface && !element.IsJVMRootType && element.IsJVMRealType)
{
par = new[] { paramType.CLRReference, paramType.ArrayElement.CLRReference };
return(CCE("ArrayStrongJ2Cp", par, invokeExpression, true));
}
par = new[] { paramType.CLRReference, paramType.ArrayElement.CLRReference };
return(CCE("ArrayFullJ2C", par, invokeExpression, true));
}
if (paramType.IsPrimitive)
{
par = new CodeTypeReference[] {};
return(CCE("PrimJ2C" + paramType.Name, par, invokeExpression, false));
}
if (paramType == Repository.javaLangString)
{
par = new CodeTypeReference[] {};
return(CCE("StrongJ2CpString", par, invokeExpression, true));
}
if (paramType == Repository.systemString)
{
par = new CodeTypeReference[] { };
return(CCE("StrongJ2CString", par, invokeExpression, true));
}
if (paramType == Repository.javaLangClass)
{
par = new CodeTypeReference[] {};
return(CCE("StrongJ2CpClass", par, invokeExpression, true));
}
if (paramType.IsDelegate)
{
par = new [] { paramType.CLRReference };
return(CCE("StrongJ2CpDelegate", par, invokeExpression, true));
}
if (!paramType.IsInterface && !paramType.IsCLRRootType && paramType.IsCLRRealType)
{
par = new[] { paramType.CLRReference };
return(CCE("StrongJp2C", par, invokeExpression, true));
}
if (!paramType.IsInterface && !paramType.IsJVMRootType && paramType.IsJVMRealType)
{
par = new[] { paramType.CLRReference };
return(CCE("StrongJ2Cp", par, invokeExpression, true));
}
par = new[] { paramType.CLRReference };
return(CCE("FullJ2C", par, invokeExpression, true));
}
private string Generate(CodeExpression expression, StringWriter sw)
{
generator.GenerateCodeFromExpression(expression, sw, options);
return(sw.ToString());
}
public static CodeCastExpression CastTo(this CodeExpression expr, Type type)
{
return(expr.CastTo(Easy.TypeRef(type)));
}
public CodeAssignStatement(CodeExpression left, CodeExpression right)
{
Left = left;
Right = right;
}
internal virtual CodeExpression BuildInvokeAsync(string messageName, CodeArrayCreateExpression paramsArray, CodeExpression delegateField, CodeExpression userStateVar)
{
CodeThisReferenceExpression ethis = new CodeThisReferenceExpression();
CodeMethodInvokeExpression inv2 = new CodeMethodInvokeExpression(ethis, "InvokeAsync");
inv2.Parameters.Add(new CodePrimitiveExpression(messageName));
inv2.Parameters.Add(paramsArray);
inv2.Parameters.Add(delegateField);
inv2.Parameters.Add(userStateVar);
return(inv2);
}
protected virtual CodeMemberField GenerateField(string name, CodeExpression value)
{
var field = gen.Field(name);
if (value != null)
{
field.InitExpression = value;
}
return field;
}
public static CodeMethodInvokeExpression InvokeMethod(this CodeExpression expr, string name, params CodeExpression[] arguments)
{
return(new CodeMethodInvokeExpression(expr, name, arguments));
}
public virtual void GenerateCodeFromExpression(CodeExpression expression, TextWriter writer, CodeGeneratorOptions options)
{
ICodeGenerator cg = CreateGenerator();
if (cg == null)
throw GetNotImplemented();
cg.GenerateCodeFromExpression(expression, writer, options);
}
public static CodeBinaryOperatorExpression Binary(CodeExpression left,
CodeBinaryOperatorType op,
CodeExpression right)
{
return(new CodeBinaryOperatorExpression(left, op, right));
}
public CodeMethodReferenceExpression(CodeExpression targetObject, string methodName, CodeTypeReference[] typeParameters) {}
static CodeBinaryOperatorExpression BooleanAnd(CodeExpression expr1, CodeExpression expr2)
{
return(new CodeBinaryOperatorExpression(expr1, CodeBinaryOperatorType.BooleanAnd, expr2));
}
/// <summary>
/// Generate client side code for calling service operations
/// </summary>
/// <param name="expression">The expression.</param>
/// <param name="rootExpression">The root code expression.</param>
/// <returns>The result of visiting this expression.</returns>
public static CodeExpression GenerateClientCode(this QueryCustomFunctionCallExpression expression, CodeExpression rootExpression)
{
// Generate this:
// return base.CreateQuery<entityType>("<Service Operation Name>").AddQueryOption("arg1", argValue1);
var entityType = expression.ExpressionType as QueryEntityType;
if (entityType == null)
{
var collectionType = expression.ExpressionType as QueryCollectionType;
if (collectionType != null)
{
entityType = collectionType.ElementType as QueryEntityType;
}
}
ExceptionUtilities.CheckObjectNotNull(entityType, "Non-entity service operations are not supported");
var codeExpression = rootExpression.Call("CreateQuery", new CodeTypeReference[] { Code.TypeRef(entityType.ClrType) }, Code.Primitive(expression.Function.Name));
for (int i = 0; i < expression.Arguments.Count; ++i)
{
var functionParameter = expression.Function.Parameters[i];
var argValue = (expression.Arguments[i] as QueryConstantExpression).ScalarValue;
if (argValue != null)
{
codeExpression = codeExpression.Call("AddQueryOption", Code.Primitive(functionParameter.Name), Code.Primitive(argValue.Value));
}
}
return(codeExpression);
}
public CodeArrayIndexerExpression(CodeExpression targetObject, params CodeExpression[] indices)
{
this.targetObject = targetObject;
this.Indices.AddRange(indices);
}
public static CodeIndexerExpression Index(this CodeExpression expr, params CodeExpression[] indices)
{
return(new CodeIndexerExpression(expr, indices));
}
public CodeMethodReturnStatement(CodeExpression expression)
{
Expression = expression;
}
internal override void Decompile(CodeExpression expression, StringBuilder stringBuilder, CodeExpression parentExpression)
{
CodeIndexerExpression expression2 = (CodeIndexerExpression)expression;
CodeExpression targetObject = expression2.TargetObject;
if (targetObject == null)
{
RuleEvaluationException exception = new RuleEvaluationException(string.Format(CultureInfo.CurrentCulture, Messages.NullIndexerTarget, new object[0]));
exception.Data["ErrorObject"] = expression2;
throw exception;
}
if ((expression2.Indices == null) || (expression2.Indices.Count == 0))
{
RuleEvaluationException exception2 = new RuleEvaluationException(string.Format(CultureInfo.CurrentCulture, Messages.MissingIndexExpressions, new object[0]));
exception2.Data["ErrorObject"] = expression2;
throw exception2;
}
RuleExpressionWalker.Decompile(stringBuilder, targetObject, expression2);
stringBuilder.Append('[');
RuleExpressionWalker.Decompile(stringBuilder, expression2.Indices[0], null);
for (int i = 1; i < expression2.Indices.Count; i++)
{
stringBuilder.Append(", ");
RuleExpressionWalker.Decompile(stringBuilder, expression2.Indices[i], null);
}
stringBuilder.Append(']');
}
public CodeExpressionStatement(CodeExpression expression)
{
Expression = expression;
}
private static void AddConstructorWithCopiedParameters(CodeTypeDeclaration codeType, Type implementationType, CodeFieldReferenceExpression omObjectFieldReference, ConstructorInfo constructorInfo)
{
CodeConstructor constructor = new CodeConstructor();
constructor.Attributes = MemberAttributes.Public;
ParameterInfo[] parameters = constructorInfo.GetParameters();
CodeExpression[] codeArgumentReferences = new CodeExpression[parameters.Length];
for (int i = 0; i < parameters.Length; i++)
{
bool isOmTypeArg = false;
string paramType = parameters[i].ParameterType.FullName;
if (OMtoPSClassMappings.ContainsKey(paramType))
{
paramType = OMtoPSClassMappings[paramType];
isOmTypeArg = true;
}
string paramName = parameters[i].Name;
string passedInArg;
// Create the proper parameter for optional
if (parameters[i].IsOptional)
{
paramName = paramType.Contains("System")
? string.Format("{0} = null", parameters[i].Name)
: string.Format("{0} = default({1})", parameters[i].Name, paramType);
}
// Need to do a null check for calling an omObject from a PS wrapper class
if (isOmTypeArg && parameters[i].IsOptional)
{
CodeVariableDeclarationStatement omObjectDeclaration = new CodeVariableDeclarationStatement(
parameters[i].ParameterType,
string.Format("{0}{1}", parameters[i].Name, "OmObject"),
new CodePrimitiveExpression(null));
constructor.Statements.Add(omObjectDeclaration);
CodeArgumentReferenceExpression omObjectArgumentReference = new CodeArgumentReferenceExpression(parameters[i].Name);
CodeAssignStatement omObjectAssignStatement = new CodeAssignStatement(new CodeVariableReferenceExpression(string.Format("{0}{1}", parameters[i].Name, "OmObject")), new CodeVariableReferenceExpression(string.Format("{0}.{1}", parameters[i].Name, OmObject)));
CodeBinaryOperatorExpression nullCheck = new CodeBinaryOperatorExpression(omObjectArgumentReference, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null));
// if the parameter is not null, use the omObject of the PS Wrapper class
constructor.Statements.Add(new CodeConditionStatement(nullCheck, omObjectAssignStatement));
passedInArg = string.Format("{0}{1}", parameters[i].Name, "OmObject");
}
else if (isOmTypeArg)
{
passedInArg = string.Format("{0}.{1}", parameters[i].Name, OmObject);
}
else
{
passedInArg = parameters[i].Name;
}
codeArgumentReferences[i] = new CodeArgumentReferenceExpression(passedInArg);
constructor.Parameters.Add(new CodeParameterDeclarationExpression(paramType, paramName));
}
CodeObjectCreateExpression createExpression = new CodeObjectCreateExpression(implementationType, codeArgumentReferences);
constructor.Statements.Add(new CodeAssignStatement(omObjectFieldReference, createExpression));
codeType.Members.Add(constructor);
}
private void EmitTupleAssignment(List<Exp> lhs, CodeExpression rhs)
{
var tup = GenSymLocalTuple();
gen.Assign(tup, rhs);
EmitTupleFieldAssignments(lhs, tup);
}
// Generate code for an expression.
protected void GenerateExpression(CodeExpression e)
{
if (e is CodeArrayCreateExpression)
{
GenerateArrayCreateExpression
((CodeArrayCreateExpression)e);
}
else if (e is CodeCastExpression)
{
GenerateCastExpression((CodeCastExpression)e);
}
else if (e is CodeMethodInvokeExpression)
{
GenerateMethodInvokeExpression
((CodeMethodInvokeExpression)e);
}
else if (e is CodeObjectCreateExpression)
{
GenerateObjectCreateExpression
((CodeObjectCreateExpression)e);
}
else if (e is CodeParameterDeclarationExpression)
{
GenerateParameterDeclarationExpression
((CodeParameterDeclarationExpression)e);
}
else if (e is CodeTypeOfExpression)
{
GenerateTypeOfExpression
((CodeTypeOfExpression)e);
}
else if (e is CodeTypeReferenceExpression)
{
GenerateTypeReferenceExpression
((CodeTypeReferenceExpression)e);
}
else if (e is CodeArgumentReferenceExpression)
{
GenerateArgumentReferenceExpression
((CodeArgumentReferenceExpression)e);
}
else if (e is CodeArrayIndexerExpression)
{
GenerateArrayIndexerExpression
((CodeArrayIndexerExpression)e);
}
else if (e is CodeBaseReferenceExpression)
{
GenerateBaseReferenceExpression
((CodeBaseReferenceExpression)e);
}
else if (e is CodeBinaryOperatorExpression)
{
GenerateBinaryOperatorExpression
((CodeBinaryOperatorExpression)e);
}
else if (e is CodeDelegateCreateExpression)
{
GenerateDelegateCreateExpression
((CodeDelegateCreateExpression)e);
}
else if (e is CodeDelegateInvokeExpression)
{
GenerateDelegateInvokeExpression
((CodeDelegateInvokeExpression)e);
}
else if (e is CodeDirectionExpression)
{
GenerateDirectionExpression
((CodeDirectionExpression)e);
}
else if (e is CodeEventReferenceExpression)
{
GenerateEventReferenceExpression
((CodeEventReferenceExpression)e);
}
else if (e is CodeFieldReferenceExpression)
{
GenerateFieldReferenceExpression
((CodeFieldReferenceExpression)e);
}
else if (e is CodeIndexerExpression)
{
GenerateIndexerExpression
((CodeIndexerExpression)e);
}
else if (e is CodeMethodReferenceExpression)
{
GenerateMethodReferenceExpression
((CodeMethodReferenceExpression)e);
}
else if (e is CodePrimitiveExpression)
{
GeneratePrimitiveExpression
((CodePrimitiveExpression)e);
}
else if (e is CodePropertyReferenceExpression)
{
GeneratePropertyReferenceExpression
((CodePropertyReferenceExpression)e);
}
else if (e is CodePropertySetValueReferenceExpression)
{
GeneratePropertySetValueReferenceExpression
((CodePropertySetValueReferenceExpression)e);
}
else if (e is CodeSnippetExpression)
{
GenerateSnippetExpression
((CodeSnippetExpression)e);
}
else if (e is CodeThisReferenceExpression)
{
GenerateThisReferenceExpression
((CodeThisReferenceExpression)e);
}
else if (e is CodeVariableReferenceExpression)
{
GenerateVariableReferenceExpression
((CodeVariableReferenceExpression)e);
}
else
{
throw new ArgumentException
(S._("Arg_InvalidCodeDom"), "e");
}
}
public CodeMethodReferenceExpression(CodeExpression targetObject, string methodName) {}
public static CodeCastExpression CastTo(this CodeExpression expr, CodeTypeReference type)
{
return(new CodeCastExpression(type, expr));
}
Type EmitAssignment(CodeExpression Left, CodeExpression Right, bool ForceTypes)
{
Depth++;
Debug("Emitting assignment expression");
Type Generated = typeof(void);
if (Left is CodeVariableReferenceExpression)
{
// local IL variables generated by parser
var Reference = Left as CodeVariableReferenceExpression;
LocalBuilder Var;
if (Locals.ContainsKey(Reference.VariableName))
{
Var = Locals[Reference.VariableName];
}
else
{
Var = Generator.DeclareLocal(typeof(int));
Locals.Add(Reference.VariableName, Var);
}
EmitExpression(Right, ForceTypes);
Generator.Emit(OpCodes.Stloc, Var);
Generator.Emit(OpCodes.Pop);
}
else if (Left is CodeArrayIndexerExpression)
{
var index = (CodeArrayIndexerExpression)Left;
Generator.Emit(OpCodes.Ldloc, VarsProperty);
EmitExpression(index.Indices[0]);
Type resultType = EmitExpression(Right, ForceTypes);
if (resultType.IsValueType)
{
Generator.Emit(OpCodes.Box, resultType);
}
Generator.Emit(OpCodes.Callvirt, SetVariable);
Generated = typeof(object);
}
else if (Left is CodePropertyReferenceExpression)
{
var prop = (CodePropertyReferenceExpression)Left;
// HACK: property set method target
var info = typeof(Rusty.Core).GetProperty(prop.PropertyName);
if (Mirror != null)
{
info = Mirror.GrabProperty(info);
}
var set = info == null ? null : info.GetSetMethod();
if (set == null)
{
Generator.Emit(OpCodes.Ldnull);
}
else
{
EmitExpression(Right);
Generator.Emit(OpCodes.Dup);
Generator.Emit(OpCodes.Call, set);
}
Generated = typeof(object);
}
else
{
throw new CompileException(Left, "Left hand is unassignable");
}
Depth--;
return(Generated);
}
public static CodeFieldReferenceExpression Field(this CodeExpression expr, string name)
{
return(new CodeFieldReferenceExpression(expr, name));
}
public CodeArrayIndexerExpression(CodeExpression targetObject, CodeExpression[] indices) {}
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);
}
