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()); }