void IIndexableVariable.EmitLoad(Block block, Expression[] expr)
{
if (resolveContext.ParameterType.IsArrayType)
{
if (resolveContext.ParameterType.Rank > 1)
{
block.Method.Generator.Emit(OpCodes.Ldarg, ParameterIndex);
foreach (Expression e in expr)
{
e.Emit();
}
block.Method.Generator.Emit(OpCodes.Ldelem);
}
else
{
//Exception
}
}
else
{
//Find indexer
}
}
public MethodCallOrArrayDereference(Statement statement, FullNamedExpression member, Expression[] args,
SourceData sourceData)
: base(statement, sourceData)
{
// TODO: Complete member initialization
Member = member;
Arguments = args;
}
void IIndexableVariable.EmitStore(Block block, Expression[] expr)
{
foreach (Expression e in expr)
{
e.Emit();
}
block.Method.Generator.Emit(getOpCode(), Assigner.GetMethodInfo());
}
public BinaryExpression(Statement statement, Operator op, Expression ret, Expression rhs, SourceData sourceData)
: base(statement, sourceData)
{
// TODO: Complete member initialization
Operator = op;
Left = ret;
Right = rhs;
Left.SetParent(this);
Right.SetParent(this);
}
public void SetInitalizationExpression(Expression expr)
{
InitializationExpression = expr;
}
public static ITypeDefinition AnalyzeExpression(MethodDef method, Expression expression,
bool shallReturnResult)
{
return null;
}
public void SetInitializationExpression(Expression initializationExpression)
{
InitializationExpression = initializationExpression;
}
public void SetExpression(Expression expr)
{
Expression = expr;
}
public void EmitStore(Block block, Expression[] expr, Expression assignExpr)
{
EmitLoad(block);
foreach (Expression e in expr)
{
e.Emit();
}
assignExpr.Emit();
block.Method.Generator.Emit(OpCodes.Stelem);
}
public void SetParent(Expression expr)
{
Parent = expr;
}
public void SetCondition(Expression expr)
{
this.Condition = expr;
}
void IIndexableVariable.EmitStore(Block block, Expression expr)
{
if (resolveContext.ParameterType.IsArrayType)
{
block.Method.Generator.Emit(OpCodes.Ldarg, ParameterIndex);
expr.Emit();
block.Method.Generator.Emit(OpCodes.Stelem);
}
}
public void Add(Expression expr)
{
Arguments.Add(expr);
}
void IIndexableVariable.EmitLoad(Block block, Expression expr)
{
expr.Emit();
block.Method.Generator.Emit(getOpCode(), Accessor.GetMethodInfo());
}
private object evaluateConstantExpression(Expression expression)
{
if (expression is IntegerConstant)
{
return ((IntegerConstant) expression).nr;
}
else
{
throw new Exception();
//Throw error
}
}
public void EmitLoad(Block block, Expression[] expr)
{
EmitLoad(block);
foreach (Expression e in expr)
{
e.Emit();
}
block.Method.Generator.Emit(OpCodes.Ldelem);
//Multi-dimensional arrays?
}
public void EmitStore(Block block, Expression[] expr)
{
int index = 0;
EmitLoad(block);
block.Method.Generator.Emit(OpCodes.Stelem, index);
}
void IIndexableVariable.EmitStore(Block block, Expression expr)
{
throw new NotSupportedException();
}
public void EmitStore(Block block, Expression expr)
{
throw new NotImplementedException();
}
