public InternalLocal DeclareTempLocal(Method node, IType type)
{
InternalLocal local = DeclareLocal(node, CreateTempName(), type);
local.IsPrivateScope = true;
return(local);
}
public Expression CreateInitValueType(LexicalInfo li, InternalLocal local)
{
MethodInvocationExpression mie = CreateBuiltinInvocation(li, BuiltinFunction.InitValueType);
mie.Arguments.Add(CreateReference(local));
return(mie);
}
public InternalLocal DeclareLocal(Method node, string name, IType type)
{
Local local = new Local(node.LexicalInfo, name);
InternalLocal entity = new InternalLocal(local, type);
local.Entity = entity;
node.Locals.Add(local);
return(entity);
}
public Declaration CreateDeclaration(Method method, string name, IType type, out InternalLocal local)
{
var result = new Declaration(name, CreateTypeReference(type));
local = this.DeclareLocal(method, name, type);
method.Locals.Add(local.Local);
result.Entity = local;
return(result);
}
public Expression CreateDefaultInitializer(LexicalInfo li, InternalLocal local)
{
if (local.Type.IsValueType)
{
return(CreateInitValueType(li, local));
}
return(CreateAssignment(
li,
CreateReference(local),
CreateNullLiteral()));
}
Expression CloneOrAssignToTemp(InternalLocal temp, Expression operand)
{
return null == temp
? operand.CloneNode()
: CodeBuilder.CreateAssignment(
CodeBuilder.CreateReference(temp),
operand.CloneNode());
}
public ReferenceExpression CreateLocalReference(InternalLocal entity)
{
return(CreateTypedReference(entity.Name, entity));
}
public Expression CreateInitValueType(LexicalInfo li, InternalLocal local)
{
return(CreateInitValueType(li, CreateReference(local)));
}
public Expression CreateDefaultInitializer(LexicalInfo li, InternalLocal local)
{
return(CreateDefaultInitializer(li, CreateReference(local), local.Type));
}
void ImplementByRefICallableCall(
Method call,
InternalCallableType type,
ClassDefinition node,
CallableSignature signature,
int byRefCount)
{
MethodInvocationExpression mie = CreateInvokeInvocation(type);
IParameter[] parameters = signature.Parameters;
ReferenceExpression args = CodeBuilder.CreateReference(call.Parameters[0]);
InternalLocal[] temporaries = new InternalLocal[byRefCount];
int byRefIndex = 0;
for (int i=0; i<parameters.Length; ++i)
{
SlicingExpression slice = CodeBuilder.CreateSlicing(args.CloneNode(), i);
IParameter parameter = parameters[i];
if (parameter.IsByRef)
{
IType tempType = parameter.Type;
if (tempType.IsByRef)
{
tempType = tempType.ElementType;
}
temporaries[byRefIndex] = CodeBuilder.DeclareLocal(call,
"__temp_" + parameter.Name,
tempType);
call.Body.Add(
CodeBuilder.CreateAssignment(
CodeBuilder.CreateReference(temporaries[byRefIndex]),
CodeBuilder.CreateCast(
tempType,
slice)));
mie.Arguments.Add(
CodeBuilder.CreateReference(
temporaries[byRefIndex]));
++byRefIndex;
}
else
{
mie.Arguments.Add(slice);
}
}
if (TypeSystemServices.VoidType == signature.ReturnType)
{
call.Body.Add(mie);
PropagateByRefParameterChanges(call, parameters, temporaries);
}
else
{
InternalLocal invokeReturnValue = CodeBuilder.DeclareLocal(call,
"__returnValue", signature.ReturnType);
call.Body.Add(
CodeBuilder.CreateAssignment(
CodeBuilder.CreateReference(invokeReturnValue),
mie));
PropagateByRefParameterChanges(call, parameters, temporaries);
call.Body.Add(
new ReturnStatement(
CodeBuilder.CreateReference(invokeReturnValue)));
}
}
public ReferenceExpression CreateLocalReference(string name, InternalLocal entity)
{
return CreateTypedReference(name, entity);
}
public Expression CreateInitValueType(LexicalInfo li, InternalLocal local)
{
MethodInvocationExpression mie = CreateBuiltinInvocation(li, BuiltinFunction.InitValueType);
mie.Arguments.Add(CreateReference(local));
return mie;
}
protected virtual IEntity DeclareLocal(Node sourceNode, string name, IType localType, bool privateScope)
{
Local local = new Local(name, privateScope);
local.LexicalInfo = sourceNode.LexicalInfo;
InternalLocal entity = new InternalLocal(local, localType);
local.Entity = entity;
_currentMethod.Method.Locals.Add(local);
return entity;
}
public ReferenceExpression CreateLocalReference(string name, InternalLocal entity)
{
return(CreateTypedReference(name, entity));
}
void SetLocal(BinaryExpression node, InternalLocal tag, bool leaveValueOnStack)
{
node.Right.Accept(this); // leaves type on stack
IType typeOnStack = null;
if (leaveValueOnStack)
{
typeOnStack = PeekTypeOnStack();
_il.Emit(OpCodes.Dup);
}
else
{
typeOnStack = PopType();
}
EmitAssignment(tag, typeOnStack);
}
void EmitAssignment(InternalLocal tag, IType typeOnStack)
{
// todo: assignment result must be type on the left in the
// case of casting
LocalBuilder local = tag.LocalBuilder;
EmitCastIfNeeded(tag.Type, typeOnStack);
_il.Emit(OpCodes.Stloc, local);
}
private ReferenceExpression CreateReference(InternalLocal enteredLoop)
{
return CodeBuilder().CreateReference(enteredLoop);
}
public InternalLocal DeclareLocal(Method node, string name, IType type)
{
Local local = new Local(node.LexicalInfo, name);
InternalLocal entity = new InternalLocal(local, type);
local.Entity = entity;
node.Locals.Add(local);
return entity;
}
public ReferenceExpression CreateReference(InternalLocal local)
{
return CreateLocalReference(local.Name, local);
}
public ReferenceExpression CreateReference(InternalLocal local)
{
return(CreateLocalReference(local.Name, local));
}
private Expression CreateSideEffectAwareSlicingOperation(LexicalInfo lexicalInfo, BinaryOperatorType binaryOperator, SlicingExpression lvalue, Expression rvalue, InternalLocal returnValue)
{
MethodInvocationExpression eval = CodeBuilder.CreateEvalInvocation(lexicalInfo);
if (HasSideEffect(lvalue.Target))
{
InternalLocal temp = AddInitializedTempLocal(eval, lvalue.Target);
lvalue.Target = CodeBuilder.CreateReference(temp);
}
foreach (Slice slice in lvalue.Indices)
{
Expression index = slice.Begin;
if (HasSideEffect(index))
{
InternalLocal temp = AddInitializedTempLocal(eval, index);
slice.Begin = CodeBuilder.CreateReference(temp);
}
}
BinaryExpression addition = CodeBuilder.CreateBoundBinaryExpression(
GetExpressionType(lvalue),
binaryOperator,
CloneOrAssignToTemp(returnValue, lvalue),
rvalue);
Expression expansion = CodeBuilder.CreateAssignment(
lvalue.CloneNode(),
addition);
// Resolve operator overloads if any
BindArithmeticOperator(addition);
if (eval.Arguments.Count > 0 || null != returnValue)
{
eval.Arguments.Add(expansion);
if (null != returnValue)
{
eval.Arguments.Add(CodeBuilder.CreateReference(returnValue));
}
BindExpressionType(eval, GetExpressionType(lvalue));
expansion = eval;
}
return expansion;
}
void PropagateByRefParameterChanges(Method call, IParameter[] parameters, InternalLocal[] temporaries)
{
int byRefIndex = 0;
for (int i=0; i<parameters.Length; ++i)
{
if (!parameters[i].IsByRef) continue;
SlicingExpression slice = CodeBuilder.CreateSlicing(
CodeBuilder.CreateReference(call.Parameters[0]),
i);
call.Body.Add(
CodeBuilder.CreateAssignment(
slice,
CodeBuilder.CreateReference(temporaries[byRefIndex])));
++byRefIndex;
}
}
public Expression CreateDefaultInitializer(LexicalInfo li, InternalLocal local)
{
if (local.Type.IsValueType)
{
return CreateInitValueType(li, local);
}
return CreateAssignment(
li,
CreateReference(local),
CreateNullLiteral());
}
