public void EmitPtr(IBlockContext context) { EmitLoad(context); using ITempBlockVariable tempLocal = context.MakeTempVariable(FieldType.UnderlyingType(context.ModuleContext)); tempLocal.EmitStore(context); tempLocal.EmitLoadPtr(context); }
public void EmitAssign(IBlockContext context, IBlockVariable variable, Node target) { using ITempBlockVariable tempRight = context.MakeTempVariable(sourceType); tempRight.EmitStore(context); context.IL.Emit(OpCodes.Pop); // Left side is just the variable we are about to override variable.EmitLoadPtr(context); EmitAssignToPtr(context, tempRight); }
public override void EmitCode(IBlockContext context, bool dropResult) { if (dropResult) { return; } using ITempBlockVariable tempVariable = context.MakeTempVariable(BuiltinType.Range); EmitStore(context, tempVariable, false); }
public override void EmitCode(IBlockContext context, bool dropResult) { if (dropResult) { return; } TupleType tupleHint = ResultType(context) as TupleType; using ITempBlockVariable tempVariable = context.MakeTempVariable(tupleHint ?? DeriveType(context)); EmitStore(context, tempVariable, false); }
public void EmitConvert(IBlockContext context) { using ITempBlockVariable valueTemp = context.MakeTempVariable(sourceType); valueTemp.EmitStore(context); Type generatedType = targetType.GeneratedType(context.ModuleContext); using ITempLocalRef someResult = context.IL.TempLocal(generatedType); someResult.EmitLoadPtr(context); EmitAssignToPtr(context, valueTemp); someResult.EmitLoad(context); }
// ---------------- IAssignEmitter ----------------- public void EmitAssign(IBlockContext context, IBlockVariable variable, Expression expression, bool dropResult) { using ITempBlockVariable valueTemp = context.MakeTempVariable(sourceType); expression.EmitStore(context, valueTemp, true); variable.EmitLoadPtr(context); EmitAssignToPtr(context, valueTemp); if (!dropResult) { variable.EmitLoad(context); } }
/// <summary> /// Variant of the Emit when a pointer to the result of the expression is required, rather /// then the value itself. /// I.e. EmitPtr will leave a pointer on the stack where the result is stored. /// </summary> public virtual void EmitPtr(IBlockContext context) { using ITempBlockVariable tempLocal = context.MakeTempVariable(ResultType(context).UnderlyingType(context.ModuleContext)); EmitStore(context, tempLocal, true); if (context.HasErrors) { return; } tempLocal.EmitLoadPtr(context); }
// ---------------- IOperatorEmitter ---------------- public void EmitCode(IBlockContext context, Node target) { using ITempBlockVariable tempRight = context.MakeTempVariable(sourceType); tempRight.EmitStore(context); Type generatedType = targetType.GeneratedType(context.ModuleContext); using ITempLocalRef someResult = context.IL.TempLocal(generatedType); someResult.EmitStore(context); someResult.EmitLoadPtr(context); EmitAssignToPtr(context, tempRight); someResult.EmitLoad(context); }
public void EmitAssign(IBlockContext context, IBlockVariable variable, Expression expression, bool dropResult) { Type generatedType = optionType.GeneratedType(context.ModuleContext); using ITempBlockVariable valueTemp = context.MakeTempVariable(optionType.elementType.UnderlyingType(context.ModuleContext)); optionType.elementType.AssignFrom(context.ModuleContext, otherType) .EmitAssign(context, valueTemp, expression, true); variable.EmitLoadPtr(context); context.IL.Emit(OpCodes.Dup); context.IL.Emit(OpCodes.Initobj, generatedType, 1, 0); context.IL.Emit(OpCodes.Dup); context.IL.Emit(OpCodes.Ldc_I4_1); context.IL.Emit(OpCodes.Stfld, generatedType.GetField("defined")); valueTemp.EmitLoad(context); context.IL.Emit(OpCodes.Stfld, generatedType.GetField("value")); if (!dropResult) { variable.EmitLoad(context); } }
public override void EmitCode(IBlockContext context, bool dropResult) { TO2Type valueType = expression.ResultType(context); TO2Type targetType = target.ResultType(context); IIndexAccessEmitter indexAccess = targetType.AllowedIndexAccess(context.ModuleContext, indexSpec); if (indexAccess == null) { context.AddError(new StructuralError( StructuralError.ErrorType.NoIndexAccess, $"Type '{targetType.Name}' does not support access by index", Start, End )); return; } if (target is IAssignContext assignContext) { if (assignContext.IsConst(context)) { context.AddError(new StructuralError( StructuralError.ErrorType.NoSuchField, $"Type '{targetType.Name}' elements can not be set on a read-only variable", Start, End )); return; } } else { context.AddError(new StructuralError( StructuralError.ErrorType.CoreGeneration, $"Index assign '{targetType.Name}'.'{indexSpec}' on invalid target expression", Start, End )); return; } if (op == Operator.Assign) { if (indexAccess.RequiresPtr) { target.EmitPtr(context); } else { target.EmitCode(context, false); } if (context.HasErrors) { return; } if (!dropResult) { using ITempBlockVariable tmpResult = context.MakeTempVariable(indexAccess.TargetType.UnderlyingType(context.ModuleContext)); indexAccess.EmitStore(context, subContext => { expression.EmitCode(subContext, false); indexAccess.TargetType.AssignFrom(subContext.ModuleContext, valueType) .EmitConvert(subContext); context.IL.Emit(OpCodes.Dup); // ReSharper disable once AccessToDisposedClosure tmpResult.EmitStore(subContext); }); tmpResult.EmitLoad(context); } else { indexAccess.EmitStore(context, subContext => { expression.EmitCode(subContext, false); indexAccess.TargetType.AssignFrom(subContext.ModuleContext, valueType).EmitConvert(subContext); }); } } else { IOperatorEmitter operatorEmitter = indexAccess.TargetType.AllowedSuffixOperators(context.ModuleContext) .GetMatching(context.ModuleContext, op, valueType); if (operatorEmitter == null) { context.AddError(new StructuralError( StructuralError.ErrorType.IncompatibleTypes, $"Index assign '{targetType.Name}'.'{indexSpec}': Cannot {op} a {indexAccess.TargetType} with a {valueType}", Start, End )); return; } expression.Prepare(context); if (indexAccess.RequiresPtr) { target.EmitPtr(context); } else { target.EmitCode(context, false); } if (context.HasErrors) { return; } if (!dropResult) { using ITempBlockVariable tmpResult = context.MakeTempVariable(indexAccess.TargetType.UnderlyingType(context.ModuleContext)); indexAccess.EmitStore(context, subContext => { if (indexAccess.RequiresPtr) { target.EmitPtr(context); } else { target.EmitCode(context, false); } indexAccess.EmitLoad(context); expression.EmitCode(subContext, false); operatorEmitter.OtherType.AssignFrom(context.ModuleContext, valueType).EmitConvert(context); operatorEmitter.EmitCode(context, this); context.IL.Emit(OpCodes.Dup); // ReSharper disable once AccessToDisposedClosure tmpResult.EmitStore(subContext); }); tmpResult.EmitLoad(context); } else { indexAccess.EmitStore(context, subContext => { if (indexAccess.RequiresPtr) { target.EmitPtr(context); } else { target.EmitCode(context, false); } indexAccess.EmitLoad(context); expression.EmitCode(subContext, false); operatorEmitter.OtherType.AssignFrom(context.ModuleContext, valueType).EmitConvert(context); operatorEmitter.EmitCode(context, this); }); } } }
public override void EmitCode(IBlockContext context, bool dropResult) { TO2Type targetType = target.ResultType(context); IFieldAccessEmitter fieldAccess = targetType.FindField(context.ModuleContext, fieldName)?.Create(context.ModuleContext); TO2Type valueType = expression.ResultType(context); if (fieldAccess == null) { context.AddError(new StructuralError( StructuralError.ErrorType.NoSuchField, $"Type '{targetType.Name}' does not have a field '{fieldName}'", Start, End )); return; } if (!fieldAccess.CanStore) { context.AddError(new StructuralError( StructuralError.ErrorType.NoSuchField, $"Type '{targetType.Name}' field '{fieldName}' is read-only", Start, End )); return; } if (target is IAssignContext assignContext) { if (fieldAccess.RequiresPtr && assignContext.IsConst(context)) { context.AddError(new StructuralError( StructuralError.ErrorType.NoSuchField, $"Type '{targetType.Name}' field '{fieldName}' can not be set on a read-only variable", Start, End )); return; } } else { context.AddError(new StructuralError( StructuralError.ErrorType.CoreGeneration, $"Field assign '{targetType.Name}'.'{fieldName}' on invalid target expression", Start, End )); return; } if (!fieldAccess.FieldType.IsAssignableFrom(context.ModuleContext, valueType)) { context.AddError(new StructuralError( StructuralError.ErrorType.IncompatibleTypes, $"Type '{targetType.Name}' field '{fieldName}' is of type {fieldAccess.FieldType} but is assigned to {valueType}", Start, End )); return; } if (op == Operator.Assign) { if (fieldAccess.RequiresPtr) { target.EmitPtr(context); } else { target.EmitCode(context, false); } if (context.HasErrors) { return; } expression.EmitCode(context, false); fieldAccess.FieldType.AssignFrom(context.ModuleContext, valueType).EmitConvert(context); if (!dropResult) { using ITempBlockVariable tmpResult = context.MakeTempVariable(fieldAccess.FieldType); context.IL.Emit(OpCodes.Dup); tmpResult.EmitStore(context); fieldAccess.EmitStore(context); tmpResult.EmitLoad(context); } else { fieldAccess.EmitStore(context); } } else { IOperatorEmitter operatorEmitter = fieldAccess.FieldType.AllowedSuffixOperators(context.ModuleContext) .GetMatching(context.ModuleContext, op, valueType); if (operatorEmitter == null) { context.AddError(new StructuralError( StructuralError.ErrorType.IncompatibleTypes, $"Type '{targetType.Name}' field '{fieldName}': Cannot {op} a {fieldAccess.FieldType} with a {valueType}", Start, End )); return; } expression.Prepare(context); if (fieldAccess.RequiresPtr) { target.EmitPtr(context); } else { target.EmitCode(context, false); } if (fieldAccess.RequiresPtr) { target.EmitPtr(context); } else { target.EmitCode(context, false); } if (context.HasErrors) { return; } fieldAccess.EmitLoad(context); expression.EmitCode(context, false); operatorEmitter.OtherType.AssignFrom(context.ModuleContext, valueType).EmitConvert(context); operatorEmitter.EmitCode(context, this); if (!dropResult) { using ITempBlockVariable tmpResult = context.MakeTempVariable(fieldAccess.FieldType); context.IL.Emit(OpCodes.Dup); tmpResult.EmitStore(context); fieldAccess.EmitStore(context); tmpResult.EmitLoad(context); } else { fieldAccess.EmitStore(context); } } }