private Action <ExpandingArray, ExpandingArray, ExpandingArray <bool> > CompileForInitializer(ResultNode resultNode)
{
this.variables = new VariableStore();
List <Expression> body = new List <Expression>();
foreach (ListNode listNode in resultNode.Lists)
{
this.AddInitializeList(listNode, body);
}
if (body.Count == 0)
{
return (a, b, c) => { }
}
;
var block = Expression.Block(body);
var lambda = Expression.Lambda <Action <ExpandingArray, ExpandingArray, ExpandingArray <bool> > >(block, ResultArgs.Lists,
ResultArgs.Dicts,
ResultArgs.Bits);
var func = lambda.Compile();
return(func);
}
private void ListCellValueNeeded(VariableStore vs, DataGridViewCellValueEventArgs e)
{
lock (vs.List)
{
if (e.RowIndex >= vs.List.Count)
{
return;
}
KeyValuePair <string, VariableList> kp = vs.List.ElementAt(e.RowIndex);
switch (e.ColumnIndex)
{
case 0:
e.Value = kp.Key;
break;
case 1:
e.Value = kp.Value.Size();
break;
case 2:
e.Value = kp.Value.Join(",");
break;
case 3:
e.Value = kp.Value.LastChanged.ToString();
break;
case 4:
e.Value = kp.Value.LastChanger;
break;
}
}
}
public ExecutorContext(Stack <Token> stack, VariableStore variableStore, IList <Token> prn, int?nextPostition = null)
{
Stack = stack;
Store = variableStore;
Prn = prn;
NextPosition = nextPostition;
}
public void ItReadsDataFromInput()
{
//Arrange
var i = new IdentifierToken("i");
var expression = new Token[]
{
i, new ReadOperation()
};
var store = new VariableStore()
{
[i] = new ConstantToken <float>(0)
};
using (var memoryStream = new MemoryStream())
{
var writer = new StreamWriter(memoryStream);
writer.WriteLine("5");
writer.Flush();
memoryStream.Position = 0;
var executor = new PrnExpressionExecutor(memoryStream);
//Act
var result = executor.ComputeExpression(expression, store);
//Assert
memoryStream.Position = 0;
Assert.AreEqual(5, store[i].Value);
}
}
public void ItWritesDataToOutput()
{
//Arrange
var i = new IdentifierToken("i");
var expression = new Token[]
{
i, new WriteOperation()
};
var store = new VariableStore()
{
[i] = new ConstantToken <float>(5)
};
using (var memoryStream = new MemoryStream())
{
var executor = new PrnExpressionExecutor(null, memoryStream);
//Act
var result = executor.ComputeExpression(expression, store);
//Assert
memoryStream.Position = 0;
Assert.AreEqual("i = 5", new StreamReader(memoryStream).ReadToEnd());
}
}
private void TableCellValueNeeded(VariableStore vs, DataGridViewCellValueEventArgs e)
{
lock (vs.Table)
{
if (e.RowIndex >= vs.Table.Count)
{
return;
}
KeyValuePair <string, VariableTable> kp = vs.Table.ElementAt(e.RowIndex);
switch (e.ColumnIndex)
{
case 0:
e.Value = kp.Key;
break;
case 1:
e.Value = kp.Value.Width;
break;
case 2:
e.Value = kp.Value.Height;
break;
case 3:
e.Value = kp.Value.LastChanged.ToString();
break;
case 4:
e.Value = kp.Value.LastChanger;
break;
}
}
}
private Action <IDataReader, ExpandingArray, ExpandingArray, ExpandingArray <bool> > CompileForList(ResultNode resultNode)
{
this.variables = new VariableStore();
if (resultNode.Lists.Count == 0)
{
return (dr, lists, dicts, bits) => { }
}
;
List <Expression> body = new List <Expression>();
foreach (ListNode listNode in resultNode.Lists)
{
this.AddListVariables(listNode, body);
}
this.AddHelperVariables(resultNode.Helpers, body);
this.AddDataReaderLoopExpression(resultNode, body);
Expression block = this.variables.ToBlock(body);
var lambda = Expression.Lambda <Action <IDataReader, ExpandingArray, ExpandingArray, ExpandingArray <bool>, ExpandingArray, Type> >(block, ResultArgs.DataReader,
ResultArgs.Lists,
ResultArgs.Dicts,
ResultArgs.Bits,
ResultArgs.Helpers,
ResultArgs.SchemaType);
var func = lambda.Compile();
ExpandingArray helpers = this.GetHelperArray(resultNode.Helpers);
Type schemaType = this.State.Schema.Model;
return((dr, lists, dicts, bits) => func(dr, lists, dicts, bits, helpers, schemaType));
}
private static void ProcessArithmeticOperations(VariableStore identifierValues,
Token token, Stack <Token> stack)
{
if (token.Substring == "+" || token.Substring == "-" || token.Substring == "*" || token.Substring == "/")
{
var operand2 = stack.Pop();
var operand1 = stack.Pop();
var floatOperand2 = (operand2 as ConstantToken <float>)?.Value ??
identifierValues[operand2 as IdentifierToken].Value;
var floatOperand1 = (operand1 as ConstantToken <float>)?.Value ??
identifierValues[operand1 as IdentifierToken].Value;
float localResult = 0;
switch (token.Substring)
{
case "*":
localResult = floatOperand1 * floatOperand2;
break;
case "/":
localResult = floatOperand1 / floatOperand2;
break;
case "+":
localResult = floatOperand1 + floatOperand2;
break;
case "-":
localResult = floatOperand1 - floatOperand2;
break;
}
stack.Push(new ConstantToken <float>(localResult));
}
}
private void RemoveAllTableVariables(VariableStore vs, DataGridView dgv)
{
lock (vs.Table)
{
vs.Table.Clear();
}
RefreshTableVariables(vs, dgv);
}
private void RefreshListVariables(VariableStore vs, DataGridView dgv)
{
lock (vs.List)
{
dgv.RowCount = vs.List.Count;
}
Refresh();
}
private void RemoveAllScalarVariables(VariableStore vs, DataGridView dgv)
{
lock (vs.Scalar)
{
vs.Scalar.Clear();
}
RefreshScalarVariables(vs, dgv);
}
private void RemoveAllListVariables(VariableStore vs, DataGridView dgv)
{
lock (vs.List)
{
vs.List.Clear();
}
RefreshListVariables(vs, dgv);
}
private void RefreshTableVariables(VariableStore vs, DataGridView dgv)
{
lock (vs.Table)
{
dgv.RowCount = vs.Table.Count;
}
Refresh();
}
private void RefreshScalarVariables(VariableStore vs, DataGridView dgv)
{
lock (vs.Scalar)
{
dgv.RowCount = vs.Scalar.Count;
}
Refresh();
}
private static void ProcessAssignment(VariableStore identifierValues, Token token, Stack <Token> stack)
{
if (token.Substring == "=")
{
var operand2 = stack.Pop();
var operand1 = stack.Pop();
identifierValues[operand1 as IdentifierToken] = operand2 as ConstantToken <float>;
}
}
private static void ProcessUnarySubtraction(VariableStore identifierValues,
Token token, Stack <Token> stack)
{
if (token.Substring == "@")
{
var operand = stack.Pop();
var floatOperand = (operand as ConstantToken <float>)?.Value ?? identifierValues[operand as IdentifierToken].Value;
stack.Push(new ConstantToken <float>(-floatOperand));
}
}
private Func <IDataReader, TItem> CompileForEnumerate <TItem>(TableIdentity heading)
{
this.variables = new VariableStore();
ItemBuilder builder = new ItemBuilder(this.State.Schema, heading);
EnumerateNode enumerateNode = builder.Build();
MetadataNode resultNode = enumerateNode.Items.FirstOrDefault(n => n.HasFlag(NodeFlags.Result));
if (resultNode == null)
{
return(r => default);
public void ItComposesPrnForLoop()
{
var logger = new LoggerConfiguration().CreateLogger();
var lexer = new Lexer(logger);
var sequence = lexer.ParseTokens(new StringReader(@"
begin
do i=1 to 10
b = b - 1
next
end")).ToList();
var executor = new BasicExecutor(logger);
var labels = lexer.Labels.ToList();
var store = new VariableStore();
var prn = executor.PrnComposer.GetPrn(sequence, labels, store);
//i 1 = _m1: _r1 c = i _r1 <= _m2 COND b b 1 - = i i 1 + = _m1 UNCOND _m2:
Assert.AreEqual(27, prn.Count);
Assert.AreEqual(true, prn[0] is IdentifierToken);
Assert.AreEqual(true, prn[1] is ConstantToken <float>);
Assert.AreEqual("=", prn[2].Substring);
Assert.AreEqual(true, prn[3] is LabelToken);
Assert.AreEqual(":", prn[4].Substring);
Assert.AreEqual(true, prn[5] is IdentifierToken);
Assert.AreEqual(true, prn[6] is ConstantToken <float>);
Assert.AreEqual("=", prn[7].Substring);
Assert.AreEqual(true, prn[8] is IdentifierToken);
Assert.AreEqual(true, prn[9] is IdentifierToken);
Assert.AreEqual("<=", prn[10].Substring);
Assert.AreEqual(true, prn[11] is LabelToken);
Assert.AreEqual(true, prn[12] is ConditionalFalseJumpOperation);
Assert.AreEqual(true, prn[13] is IdentifierToken);
Assert.AreEqual(true, prn[14] is IdentifierToken);
Assert.AreEqual(true, prn[15] is ConstantToken <float>);
Assert.AreEqual("-", prn[16].Substring);
Assert.AreEqual("=", prn[17].Substring);
Assert.AreEqual(true, prn[18] is IdentifierToken);
Assert.AreEqual(true, prn[19] is IdentifierToken);
Assert.AreEqual(true, prn[20] is ConstantToken <float>);
Assert.AreEqual("+", prn[21].Substring);
Assert.AreEqual("=", prn[22].Substring);
Assert.AreEqual(true, prn[23] is LabelToken);
Assert.AreEqual(true, prn[24] is UnconditionalJumpOperation);
Assert.AreEqual(true, prn[25] is LabelToken);
Assert.AreEqual(":", prn[26].Substring);
}
private void AddScalarVariable(VariableStore vs, DataGridView dgv)
{
VariableScalar v = new VariableScalar();
string varname = "";
v = (VariableScalar)OpenVariableEditor(v, ref varname, true);
if (v != null)
{
lock (vs.Scalar)
{
vs.Scalar[varname] = v;
}
RefreshScalarVariables(vs, dgv);
}
}
private void AddListVariable(VariableStore vs, DataGridView dgv)
{
VariableList v = new VariableList();
string varname = "";
v = (VariableList)OpenVariableEditor(v, ref varname, true);
if (v != null)
{
lock (vs.List)
{
vs.List[varname] = v;
}
RefreshListVariables(vs, dgv);
}
}
private void AddTableVariable(VariableStore vs, DataGridView dgv)
{
VariableTable v = new VariableTable();
string varname = "";
v = (VariableTable)OpenVariableEditor(v, ref varname, true);
if (v != null)
{
lock (vs.Table)
{
vs.Table[varname] = v;
}
RefreshTableVariables(vs, dgv);
}
}
public void ItMakesAssignments()
{
var i = new IdentifierToken("i");
var expression = new Token[]
{
i, new ConstantToken <float>(2), new StringToken("=")
};
var store = new VariableStore()
{
[i] = new ConstantToken <float>(0)
};
var executor = new PrnExpressionExecutor();
var result = executor.ComputeExpression(expression, store);
Assert.AreEqual(2, store[i].Value);
}
private static void ProcessBoolean(VariableStore identifierValues, Token token, Stack <Token> stack)
{
if (token.Substring == ">" || token.Substring == "<" || token.Substring == "==" ||
token.Substring == "<=" || token.Substring == ">=" || token.Substring == "!=")
{
var operand2 = stack.Pop();
var operand1 = stack.Pop();
var floatOperand2 = (operand2 as ConstantToken <float>)?.Value ??
identifierValues[operand2 as IdentifierToken].Value;
var floatOperand1 = (operand1 as ConstantToken <float>)?.Value ??
identifierValues[operand1 as IdentifierToken].Value;
float localResult = 0;
switch (token.Substring)
{
case ">":
localResult = floatOperand1 > floatOperand2 ? 1.0f : 0.0f;
break;
case "<":
localResult = floatOperand1 < floatOperand2 ? 1.0f : 0.0f;
break;
case "<=":
localResult = floatOperand1 <= floatOperand2 ? 1.0f : 0.0f;
break;
case ">=":
localResult = floatOperand1 >= floatOperand2 ? 1.0f : 0.0f;
break;
case "==":
localResult = floatOperand1 == floatOperand2 ? 1.0f : 0.0f;
break;
case "!=":
localResult = floatOperand1 != floatOperand2 ? 1.0f : 0.0f;
break;
}
stack.Push(new ConstantToken <float>(localResult));
}
}
public void ItComputesNegatedLogicalExpressions()
{
var i = new IdentifierToken("i");
var res = new IdentifierToken("res");
var expression = new Token[]
{
res, i, new ConstantToken <float>(2), new StringToken("=="), new StringToken("!"), new StringToken("=")
};
var store = new VariableStore()
{
[i] = new ConstantToken <float>(2),
[res] = new ConstantToken <float>(1)
};
var executor = new PrnExpressionExecutor();
var result = executor.ComputeExpression(expression, store);
Assert.AreEqual(0, store[res].Value);
}
public void ItComputesComplexExpressions()
{
var i = new IdentifierToken("i");
var res = new IdentifierToken("res");
var expression = new Token[]
{
res, new StringToken("["), i, new ConstantToken <float>(2), new StringToken("=="), i, new ConstantToken <float>(3), new StringToken("<"), new StringToken("and"),
new StringToken("]"), new StringToken("=")
};
var store = new VariableStore()
{
[i] = new ConstantToken <float>(2),
[res] = new ConstantToken <float>(0)
};
var executor = new PrnExpressionExecutor();
var result = executor.ComputeExpression(expression, store);
Assert.AreEqual(1, store[res].Value);
}
public MainWindow()
{
_lexer = _scope.Resolve <Lexer>();
_parser = _scope.Resolve <IParser>();
_variables = _scope.Resolve <VariableStore>();
_executor = _scope.Resolve <IExecutor>();
ViewModel = _scope.Resolve <Func <VariableStore, MainWindowViewModel> >()(_variables);
_executor.Output += s => outputTextBox.Text += s;
_executor.ComputationStep += (s, i, stack) => ViewModel.ComputationSteps.Add(new ComputationStep()
{
Before = string.Join(" ", s.Take(i)),
Highlighted = s.ElementAt(i).ToString(),
After = string.Join(" ", s.Skip(i + 1)),
Stack = string.Join(" ", stack)
});
InitializeComponent();
}
public void ItMakesUnconditionalJumps()
{
var i = new IdentifierToken("i");
var expression = new Token[]
{
new LabelToken("t"), new StringToken(":"),
new LabelToken("test"), new UnconditionalJumpOperation(),
i, new ConstantToken <float>(1), new StringToken("="),
new LabelToken("test"), new StringToken(":")
};
var store = new VariableStore()
{
[i] = new ConstantToken <float>(0)
};
var executor = new PrnExpressionExecutor();
var result = executor.ComputeExpression(expression, store);
Assert.AreEqual(0, store[i].Value);
}
private void EditTableVariable(VariableStore vs, DataGridView dgv)
{
string varname = "";
foreach (DataGridViewRow r in dgv.SelectedRows)
{
varname = r.Cells[0].Value.ToString();
}
VariableTable v = null;
lock (vs.Table)
{
if (vs.Table.ContainsKey(varname) == true)
{
v = vs.Table[varname];
}
}
if (v == null)
{
v = new VariableTable();
}
string varname2 = varname;
v = (VariableTable)OpenVariableEditor(v, ref varname2, false);
if (v != null)
{
lock (vs.Table)
{
if (varname != varname2)
{
if (vs.Table.ContainsKey(varname) == true)
{
vs.Table.Remove(varname);
}
}
vs.Table[varname2] = v;
}
RefreshTableVariables(vs, dgv);
}
}
public void ItExecutesLoop()
{
var logger = new LoggerConfiguration().CreateLogger();
//Arrange
var i = new IdentifierToken("i");
var j = new IdentifierToken("j");
var res = new IdentifierToken("sum");
var lexer = new Lexer(logger);
var sequence = lexer.ParseTokens(new StringReader(@"
begin
do i=1 to 5
do j=2 to 7
sum = sum + i*j
next
next
end")).ToList();
var store = new VariableStore()
{
[i] = new ConstantToken <float>(0),
[j] = new ConstantToken <float>(0),
[res] = new ConstantToken <float>(0)
};
var prnProvider = new BasicExecutor(logger);
var labels = lexer.Labels.ToList();
var prn = prnProvider.PrnComposer.GetPrn(sequence, labels, store);
var executor = new PrnExpressionExecutor();
//Act
var result = executor.ComputeExpression(prn, store);
//Assert
Assert.AreEqual(5 + 1, store[i].Value);
Assert.AreEqual(7 + 1, store[j].Value);
Assert.AreEqual(405, store[res].Value);
}
public static IEnumerator ReloadAnimation(GunStats forGun, Transform at, VariableStore variableStore)
{
ReloadAnimation currentReloadAnimation = Instantiate <ReloadAnimation>(forGun.reloadAnimation);
currentReloadAnimation.transform.SetParent(at, false);
currentReloadAnimation.transform.localPosition = Vector3.zero;
int currentShots = 0;
currentReloadAnimation.SetShotCount(currentShots);
yield return(AsyncUtil.Pause(forGun.reloadDelay));
while (currentShots < forGun.capacity)
{
++currentShots;
forGun.SetShotsLeft(variableStore, currentShots);
currentReloadAnimation.SetShotCount(currentShots);
yield return(AsyncUtil.Pause(forGun.reloadBulletDuration));
}
Destroy(currentReloadAnimation.gameObject);
}
internal void Execute(VariableStore variableStore) {
variables = vars = new Variables(variableStore);
Main();
}
private void Execute(VariableStore variableStore) {
vars = new Variables(variableStore);
Main();
}
public MsgSetVariablePacket(VariableStore variable)
{
this.TypeCode = variable.TypeCode;
this.Name = variable.Name;
this.Value = variable.Value;
}
protected ProblemDefinitionScript(ProblemDefinitionScript original, Cloner cloner)
: base(original, cloner) {
variableStore = cloner.Clone(original.variableStore);
codeChanged = original.codeChanged;
}
protected ProblemDefinitionScript()
: base() {
variableStore = new VariableStore();
}
protected ProblemDefinitionScript(string code)
: base(code) {
variableStore = new VariableStore();
}
public KeyValueController(VariableStore store)
{
_store = store;
}
protected CSharpScript(CSharpScript original, Cloner cloner)
: base(original, cloner) {
variableStore = cloner.Clone(original.variableStore);
}
public CSharpScript(string code)
: base(code) {
variableStore = new VariableStore();
}
public CSharpScript()
: base(ScriptTemplates.CSharpScriptTemplate) {
variableStore = new VariableStore();
}
