protected internal virtual void VisitSpan(HelperHeaderSpan span)
{
Debug.Assert(InHelper);
CurrentBlock.WriteLinePragma = DesignTimeMode;
if (!DesignTimeMode)
{
CurrentBlock.Writer.WriteHiddenLinePragma();
}
// Write the prefix
CurrentBlock.Writer.WriteHelperHeaderPrefix(Host.GeneratedClassContext.TemplateTypeName, isStatic: Host.StaticHelpers);
CurrentBlock.MarkStartGeneratedCode();
CurrentBlock.Writer.WriteSnippet(span.Content);
CurrentBlock.MarkEndGeneratedCode();
if (span.Complete)
{
CurrentBlock.Writer.WriteHelperHeaderSuffix(Host.GeneratedClassContext.TemplateTypeName);
}
CurrentBlock.Writer.InnerWriter.WriteLine();
if (span.Complete)
{
CurrentBlock.Writer.WriteReturn();
CurrentBlock.Writer.WriteStartConstructor(Host.GeneratedClassContext.TemplateTypeName);
CurrentBlock.Writer.WriteStartLambdaDelegate(HelperWriterName);
CurrentHelper.WroteHelperPrefix = true;
}
WriteBlockToHelperContent(CurrentBlock);
CurrentBlock.ResetBuffer();
}
protected virtual void CreateBlockRegions(PDFLayoutBlock containerBlock, PDFPositionOptions position, PDFColumnOptions columnOptions)
{
PDFRect unused = containerBlock.CurrentRegion.UnusedBounds;
PDFUnit yoffset = containerBlock.CurrentRegion.Height;
PDFRect total = new PDFRect(PDFUnit.Zero, yoffset, unused.Width, unused.Height);
if (position.Width.HasValue)
{
total.Width = position.Width.Value;
}
//ADDED for min/max sizes. Include the margins as we are making this the available width.
else if (position.MaximumWidth.HasValue)
{
total.Width = position.MaximumWidth.Value + position.Margins.Left + position.Margins.Right;
}
if (position.Height.HasValue)
{
total.Height = position.Height.Value;
}
//ADDED for min/max sizes. Include the margins as we are making this the available height.
else if (position.MaximumHeight.HasValue)
{
total.Height = position.MaximumHeight.Value + position.Margins.Top + position.Margins.Bottom;
}
CurrentBlock.InitRegions(total, position, columnOptions, this.Context);
}
//入力をとって動作まで
private void inputButton(ref CurrentBlock tmp)
{
if (Input.GetKeyDown(KeyCode.RightArrow))
{
Debug.Log("right");
tmp = current.MoveRight();
button_on = true;
}
else if (Input.GetKeyDown(KeyCode.LeftArrow))
{
Debug.Log("left");
tmp = current.MoveLeft();
button_on = true;
}
else if (Input.GetKeyDown(KeyCode.Space))
{
Debug.Log("rotate");
tmp = current.Rotate();
button_on = true;
transform.Rotate(new Vector3(0f, 0f, 90f));
}
else if (Input.GetKeyDown(KeyCode.DownArrow))
{
Debug.Log("under");
moveUnder(ref tmp);
button_on = true;
}
}
/// <summary>
/// Event handler from the input class that get's triggered when input is available
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private void OnKeyPressed(object sender, KeyEventArgs args)
{
if (args.Key == KeyEventArgs.Keys.RotateL)
{
CurrentBlock.SafeRotate(gameBoard);
}
if (args.Key == KeyEventArgs.Keys.Left)
{
CurrentBlock.SafeMoveLeft(gameBoard);
}
if (args.Key == KeyEventArgs.Keys.Right)
{
CurrentBlock.SafeMoveRight(gameBoard);
}
if (args.Key == KeyEventArgs.Keys.Down)
{
CurrentBlock.SafeFall(gameBoard);
}
if (args.Key == KeyEventArgs.Keys.Exit)
{
GameOver();
}
// Draw again after a key is pressed
Draw();
}
/// <summary>
/// Realizes an indirect load instruction.
/// </summary>
/// <param name="type">The target type.</param>
private void MakeLoadObject(Type type)
{
var address = CurrentBlock.Pop();
address = CreateConversion(address, type.MakePointerType());
CurrentBlock.Push(type, BuildLoad(Builder, address.LLVMValue, string.Empty));
}
/// <summary>
/// Realizes an arithmetic mul operation.
/// </summary>
/// <param name="overflow">True, if an overflow has to be checked.</param>
private void MakeArithmeticMul(bool overflow)
{
if (overflow)
{
throw new NotSupportedException();
}
Type type = CurrentBlock.PopArithmeticArgs(out LLVMValueRef left, out LLVMValueRef right);
var name = string.Empty;
var basicValueType = type.GetBasicValueType();
if (basicValueType.IsFloat())
{
if (Unit.HasFlags(CompileUnitFlags.UseGPUMath))
{
MakeIntrinsicMathOperation(
type,
basicValueType == BasicValueType.Single ? MathMulF32 : MathMulF64,
left,
right);
}
else
{
CurrentBlock.Push(type, BuildFMul(Builder, left, right, name));
}
}
else
{
CurrentBlock.Push(type, BuildMul(Builder, left, right, name));
}
}
/// <summary>
/// Realizes a new-array instruction.
/// </summary>
/// <param name="elementType">The element type of the array.</param>
private void MakeNewArray(Type elementType)
{
var stackValue = CurrentBlock.Pop();
var arrayLength = stackValue.LLVMValue;
if (!IsConstant(arrayLength))
{
throw CompilationContext.GetNotSupportedException(ErrorMessages.NotSupportedArrayCreation);
}
// Allocate the element data first in a local alloca
var llvmElementType = Unit.GetType(elementType);
var arrayLengthValue = (int)ConstIntGetZExtValue(arrayLength);
var llvmAllocaArrayType = ArrayType(llvmElementType, arrayLengthValue);
var arrayData = CreateTempAlloca(llvmAllocaArrayType);
BuildStore(Builder, ConstNull(llvmAllocaArrayType), arrayData);
// Array<T> = (T*, int32)
var arrayType = elementType.MakeArrayType();
var llvmArrayType = Unit.GetType(arrayType);
var initialArrayValue = GetUndef(llvmArrayType);
// Setup T*: (T*, undef)
var basePtr = BuildPointerCast(Builder, arrayData, PointerType(llvmElementType), string.Empty);
var arrayWithPointer = BuildInsertValue(Builder, initialArrayValue, basePtr, 0, string.Empty);
// Setup length: (T*, int32)
var array = BuildInsertValue(Builder, arrayWithPointer, arrayLength, 1, string.Empty);
// Push the final array value
CurrentBlock.Push(arrayType, array);
}
public override bool VisitStmtReturnValue([NotNull] GamaParser.StmtReturnValueContext context)
{
if (Self.ReturnType == InstanceTypes.Void)
{
NamespaceContext.Context.AddError(new ErrorVoidReturnsValue(context));
return(false);
}
var val = VisitExpression(Self.ReturnType, context.expr());
if (val == null)
{
return(false);
}
if (Self.ReturnType != val.Type)
{
NamespaceContext.Context.AddError(new ErrorTypeMismatch(context.expr()));
return(false);
}
/* LLVM */
CurrentBlock.PositionBuilderAtEnd(Builder);
Builder.BuildRet(val.Value);
return(true);
}
public int Finish()
{
// Assuming current block is last block
CurrentBlock.PositionBuilderAtEnd(Builder);
if (!CurrentBlock.HasTerminator())
{
if (Self.ReturnType != InstanceTypes.Void)
{
// TODO: fix your sh*tty error system (and error generator too)
// ALSO: possibly add (and improve) super konsole lib
NamespaceContext.Context.AddError(new GamaError("Function did not return a value, did you meant to use void return type? Expected {0} got nothing.", Self.ReturnType.Name));
return(-1);
}
// If self is void, no need to worry, just BuildRetVoid()
Builder.BuildRetVoid();
}
Builder.Dispose();
// Run optimizations of self
// new Optimizers.AllocToEntry().Visit(this);
// new Optimizers.ControlFlowEliminator().Visit(this);
// new Optimizers.DeadBlockEliminator().Visit(this);
return(0);
}
public override bool VisitStmtVarDefBase([NotNull] GamaParser.StmtVarDefBaseContext context)
{
var name = context.Symbol().GetText();
var val = Top.FindValue(name);
// Duplicate variable definition (parent frames can have same variable, it will be overriden in current frame)
if (val != null)
{
NamespaceContext.Context.AddError(new ErrorDuplicateVariable(context));
return(false);
}
val = VisitExpression(context.expr());
if (val == null)
{
return(false);
}
/* LLVM */
CurrentBlock.PositionBuilderAtEnd(Builder);
var alloc = Builder.BuildAlloca(val.Type.UnderlyingType, name);
Builder.BuildStore(val.Value, alloc);
Top.AddValue(name, new GamaValueRef(val.Type, alloc, true));
return(true);
}
/// <summary>
/// Realizes a new-object operation that creates a new instance of a specified type.
/// </summary>
/// <param name="method">The target method.</param>
private void MakeNewObject(MethodBase method)
{
var constructor = method as ConstructorInfo;
if (constructor == null)
{
throw CompilationContext.GetInvalidILCodeException();
}
var type = constructor.DeclaringType;
var llvmType = Unit.GetType(type);
// Use a temporary alloca to realize object creation
// and initialize object with zero
var tempAlloca = CreateTempAlloca(llvmType);
BuildStore(Builder, ConstNull(llvmType), tempAlloca);
// Invoke constructor for type
Value[] values = new Value[constructor.GetParameters().Length + 1];
values[0] = new Value(type.MakePointerType(), tempAlloca);
CurrentBlock.PopMethodArgs(constructor, values, 1);
CreateCall(constructor, values);
// Push created instance on the stack
if (type.IsValueType)
{
CurrentBlock.Push(type, BuildLoad(Builder, values[0].LLVMValue, string.Empty));
}
else
{
CurrentBlock.Push(values[0]);
}
}
/// <summary>
/// Loads the length of an array.
/// </summary>
private void LoadArrayLength()
{
var array = CurrentBlock.Pop();
Debug.Assert(array.ValueType.IsArray);
CurrentBlock.Push(typeof(int), BuildExtractValue(Builder, array.LLVMValue, 1, "ldlen"));
}
/// <summary>
/// Realizes an arithmetic rem operation.
/// </summary>
/// <param name="forceUnsigned">True, if the comparison should be forced to be unsigned.</param>
private void MakeArithmeticRem(bool forceUnsigned = false)
{
Type type = CurrentBlock.PopArithmeticArgs(out LLVMValueRef left, out LLVMValueRef right);
var name = string.Empty;
var basicValueType = type.GetBasicValueType();
if (basicValueType.IsFloat())
{
if (Unit.HasFlags(CompileUnitFlags.UseGPUMath))
{
MakeIntrinsicMathOperation(
type,
basicValueType == BasicValueType.Single ? MathRemF32 : MathRemF64,
left,
right);
}
else
{
CurrentBlock.Push(type, BuildFRem(Builder, left, right, name));
}
}
else if (forceUnsigned || basicValueType.IsUnsignedInt())
{
CurrentBlock.Push(type, BuildURem(Builder, left, right, name));
}
else
{
CurrentBlock.Push(type, BuildSRem(Builder, left, right, name));
}
}
/// <summary>
/// Creates a call instruction to the given method with the given arguments.
/// </summary>
/// <param name="target">The target method to invoke.</param>
/// <param name="args">The call arguments</param>
private void CreateCall(MethodBase target, Value[] args)
{
var intrinsicContext = new InvocationContext(Builder, Method, target, args, this);
// Check for remapping first
var remappedContext = Unit.RemapIntrinsic(intrinsicContext);
if (remappedContext != null)
{
intrinsicContext = remappedContext.Value;
}
// Early rejection for runtime-dependent methods
VerifyNotRuntimeMethod(CompilationContext, intrinsicContext.Method);
// Handle device functions
if (!Unit.HandleIntrinsic(intrinsicContext, out Value? methodInvocationResult))
{
var method = Unit.GetMethod(intrinsicContext.Method);
var llvmArgs = new LLVMValueRef[args.Length];
for (int i = 0, e = args.Length; i < e; ++i)
{
llvmArgs[i] = args[i].LLVMValue;
}
var call = BuildCall(Builder, method.LLVMFunction, llvmArgs);
if (!method.IsVoid)
{
methodInvocationResult = new Value(method.ReturnType, call);
}
}
if (methodInvocationResult.HasValue)
{
CurrentBlock.Push(methodInvocationResult.Value);
}
}
public void Print()
{
CurrentBlock.Print();
Console.WriteLine("==============================================================");
Before?.Print();
}
public LiveBuildHelperVM(IDominoProvider pFParameters, int pBlockSize, Core.Orientation orientation, bool MirrorX, bool MirrorY)
{
BlockSize = pBlockSize;
fParameters = pFParameters;
intField = fParameters.GetBaseField(orientation, MirrorX, MirrorY);
NextN = 500;
CountRow = intField.GetLength(1);
stonesPerLine = intField.GetLength(0);
CountBlock = Convert.ToInt32(Math.Ceiling(((double)stonesPerLine / BlockSize)));
SizeChanged = new RelayCommand(o => { RefreshCanvas(); });
MouseDown = new RelayCommand(o => { CurrentBlock.Focus(); });
PositionSnapshots = new ObservableCollection <PositionSnapshot>();
MakePositionSnapshot = new RelayCommand(o => {
PositionSnapshots.RemoveAll(x => x.Column == SelectedBlock && x.Row == SelectedRow);
if ((bool)o == true)
{
PositionSnapshots.Insert(0, new PositionSnapshot()
{
Column = SelectedBlock, Row = SelectedRow
});
}
RaisePropertyChanged(nameof(PositionSnapshots));
});
GoToPositionSnapshot = new RelayCommand(o => { if (o is PositionSnapshot ps)
{
SelectedBlock = ps.Column; SelectedRow = ps.Row;
}
});
ColumnConfig = new AvaloniaList <Column>
{
new Column()
{
DataField = "DominoColor.mediaColor", Header = "", Class = "Color"
},
new Column()
{
DataField = "DominoColor.name", Header = _("Name")
},
new Column()
{
DataField = "ProjectCount[0]", Header = GetParticularString("Number of stones available", "Total")
},
new Column()
{
DataField = "ProjectCount[1]", Header = GetParticularString("Remaining number of stones", "Remaining"), Class = "Count"
},
new Column()
{
DataField = "ProjectCount[2]", Header = string.Format(GetParticularString("Dominoes of the given color within the next {0}", "Next {0}"), NextN)
}
};
OpenPopup = new RelayCommand(x => { FillColorList(); PopupOpen = true; });
CurrentStones = new ObservableCollection <SolidColorBrush>();
HistStones = new ObservableCollection <SolidColorBrush>();
ColorNames = new ObservableCollection <ColorAmount>();
RefreshCanvas();
}
/// <summary>
/// Loads a value of the given type from an unsafe memory address.
/// </summary>
/// <param name="type">The type of the value to load.</param>
private void LoadIndirect(Type type)
{
var address = CurrentBlock.Pop(type.MakePointerType());
var load = BuildLoad(Builder, address.LLVMValue, "ldind");
CurrentBlock.Push(type, load);
}
/// <summary>
/// Stores a value to an unsafe address.
/// </summary>
/// <param name="type">The type of the value to store.</param>
private void StoreIndirect(Type type)
{
var value = CurrentBlock.Pop(type);
var address = CurrentBlock.Pop(type.MakePointerType());
BuildStore(Builder, value.LLVMValue, address.LLVMValue);
}
public override bool VisitStmtAssign([NotNull] GamaParser.StmtAssignContext context)
{
ExpressionCompiler.PushLoad(false);
var lhs = VisitExpression(context.expr(0));
ExpressionCompiler.PopLoad();
if (lhs == null)
{
return(false);
}
if (!lhs.IsModifiableLValue)
{
NamespaceContext.Context.AddError(new ErrorAssignToNonModLValue(context.expr(0)));
return(false);
}
var value = VisitExpression(lhs.Type, context.expr(1));
if (value == null)
{
NamespaceContext.Context.AddError(new ErrorTypeMismatch(context.expr(1)));
return(false);
}
/* LLVM */
CurrentBlock.PositionBuilderAtEnd(Builder);
Builder.BuildStore(value.Value, lhs.Value);
return(true);
}
/// <summary>
/// Loads a variable address. This can be an argument or a local reference.
/// </summary>
/// <param name="var">The variable reference.</param>
private void LoadVariableAddress(VariableRef var)
{
Debug.Assert(var.RefType == VariableRefType.Argument || var.RefType == VariableRefType.Local);
var value = variables[var];
CurrentBlock.Push(value.ValueType.MakePointerType(), value.LLVMValue);
}
/// <summary>
/// Loads the value of a field specified by the given metadata token.
/// </summary>
/// <param name="field">The field.</param>
private void LoadField(FieldInfo field)
{
var value = CurrentBlock.Pop();
var name = string.Empty;
if (value.ValueType.IsTreatedAsPtr())
{
var address = LoadFieldAddress(field, value);
CurrentBlock.Push(field.FieldType, BuildLoad(Builder, address, name));
}
else
{
// It is a value object
do
{
var mappedType = Unit.GetObjectType(value.ValueType);
if (mappedType.TryResolveOffset(field, out int offset))
{
value = new Value(field.FieldType, BuildExtractValue(Builder, value.LLVMValue, offset, name));
break;
}
var baseType = value.ValueType.BaseType;
if (baseType == null)
{
throw new InvalidOperationException();
}
value = new Value(baseType, BuildExtractValue(Builder, value.LLVMValue, 0, name));
}while (value.ValueType.BaseType != null);
CurrentBlock.Push(value);
}
}
/// <summary>
/// Realizes an indirect store instruction.
/// </summary>
/// <param name="type">The target type.</param>
private void MakeStoreObject(Type type)
{
var value = CurrentBlock.Pop(type);
var address = CurrentBlock.Pop();
address = CreateConversion(address, type.MakePointerType());
BuildStore(Builder, value.LLVMValue, address.LLVMValue);
}
/// <summary>
/// Stores a value to a field.
/// </summary>
/// <param name="field">The field.</param>
private void StoreField(FieldInfo field)
{
var value = CurrentBlock.Pop(field.FieldType);
var fieldValue = CurrentBlock.Pop();
var fieldAddress = LoadFieldAddress(field, fieldValue);
BuildStore(Builder, value.LLVMValue, fieldAddress);
}
/// <summary>
/// Loads a static field specified by the given metadata token.
/// </summary>
/// <param name="field">The field.</param>
private void LoadStaticField(FieldInfo field)
{
VerifyStaticFieldLoad(CompilationContext, Unit.Flags, field);
var value = field.GetValue(null);
CurrentBlock.Push(field.FieldType, Unit.GetValue(field.FieldType, value));
}
/// <summary>
/// Loads the constant null.
/// </summary>
private void LoadNull()
{
var t = typeof(object);
CurrentBlock.Push(
t.MakePointerType(),
ConstNull(Unit.GetType(t)));
}
internal void MoveToNextLine()
{
var nextLine = CurrentBlock.GetNextLine(CurrentLine);
TraceVerbose($"Internal: moving to next line {nextLine.Id.ToStringDebug()}");
_progress.CurrentLineId = nextLine.Id;
}
private void EndBlock()
{
//Debug.Log("EndBlock: " + CurrentBlock.Config);
CurrentBlock.Close();
//LoadScene("debriefing");
LoadScene(null);
menue.enabled = true;
ContinueButton.Deactivate();
}
private static void MakeDataField(string FileAddress)
{
var Bytes = System.IO.File.ReadAllBytes(FileAddress);
CurrentBlock.NewBlock(() =>
{
CurrentBlock += $"public static readonly string Url =\"data:image/gif;base64,{Convert.ToBase64String(Bytes)}\";";
});
}
public void EndTrial()
{
bool blockFinished = CurrentBlock.EndCurrentTrial();
if (blockFinished)
{
EndBlock();
}
}
/// <summary>
/// Loads the address of an array element.
/// </summary>
private void LoadArrayElementAddress()
{
var idx = CurrentBlock.PopInt();
var array = CurrentBlock.Pop();
Debug.Assert(array.ValueType.IsArray);
var addr = ComputeArrayAddress(array.LLVMValue, idx.LLVMValue);
CurrentBlock.Push(array.ValueType.GetElementType().MakePointerType(), addr);
}
