public string ReorderPost(string code)
{
var d0 = code.ToStack();
var d1 = ReorderInterpreter.RunReorderPost(d0);
return(interpreter.StackToString(d1));
}
public void TestReorderInstruction()
{
interpreter = reorderInterpreter;
Assert.Equal("[[] R<int>[2 R<int>[3 5 +] +]]", Run("[[2 3 5 + +]]"));
Assert.Equal("[[2 3 5 + +]]", ReorderInterpreter.ReorderPost(lastRun).ToRepr());
Assert.Equal("[[] a R<int>[2 R<int>[3 5 +] +]]", Run("[[2 3 a 5 + +]]"));
Assert.Equal("[[2 3 5 + + a]]", ReorderInterpreter.RunReorderPost(lastRun).ToRepr());
Assert.Equal("[[] R<int>[3 5 +]]", Run("[[3 5 + +]]"));
Assert.Equal("[[3 5 +]]", ReorderInterpreter.RunReorderPost(lastRun).ToRepr());
}
public void testLotsOfReordering()
{
Assert.Equal("[[] d c b a 10]", Run("[[2 a 3 b c 5 + d +]]"));
Stack s1, s2;
// Assert.Equal("[[] d c b a R[2 R[3 5 +] +]]", (s1 = interpreter.RunReorderPre("[[2 a 3 b c 5 + d +]]".ToStack())).ToRepr());
Assert.Equal("[[] d c b a R<int>[2 R<int>[3 5 +] +]]", (s1 = reorderInterpreter.Run("[[2 a 3 b c 5 + d +]]".ToStack())).ToRepr());
Assert.Equal("[[2 3 5 + + a b c d]]", (s2 = ReorderInterpreter.RunReorderPost(s1)).ToRepr());
Assert.Equal("[[] d c b a 10]", strictInterpreter.Run(s2).ToRepr());
}
public void TestReorderWithAssignment()
{
Assert.Equal("[[] 3]", Run("[[1 x 2 ! x +]]"));
var s = new Stack(new object[] { new Defer("[x 2 !]".ToStack(), typeof(void)),
new Defer("[1 x +]".ToStack(), typeof(int)), new Stack() });
Assert.Equal("[[] R<int>[1 x +] R<Void>[x 2 !]]", s.ToRepr());
Assert.Equal("[[x 2 ! 1 x +]]", ReorderInterpreter.RunReorderPost(s).ToRepr());
Assert.Equal("[[] R<int>[1 R<int>[x] +] R<Void>[x 2 !]]", ReorderPre("[[1 x 2 ! x +]]"));
reorderInterpreter.instructions.Remove("x");
Assert.Equal("[[x 2 ! 1 x +]]", Reorder("[[1 x 2 ! x +]]"));
interpreter.instructions.Remove("x");
Assert.Equal("[[] x 1]", Run("[[1 x + x 2 !]]"));
interpreter.instructions.Remove("x");
Assert.Equal("[[] 2 1]", Run("[[1 x 2 ! x]]"));
}
public void TestReorderBugFoundInWild()
{
interpreter = reorderInterpreter;
Assert.Equal("[[]]", Run("[[dup]]"));
Assert.Equal("[[]]", Run("[[pop]]"));
// Assert.Equal("[[] R[-3 pop]]", Run("[[-3 pop]]"));
Assert.Equal("[[] R<Void>[-3 pop]]", Run("[[-3 pop]]"));
Assert.Equal("[[] R<int>[1 dup] R<int>[1 dup] R<Void>[-3 pop]]", Run("[[1 -3 pop dup]]"));
Assert.Equal("[[] R<Void>[-3 pop]]", Run("[[-3 pop]]"));
Assert.Equal("[[] R<Void>[-3 pop]]", Run("[[-3 pop dup]]"));
Assert.Equal("[[] R<Void>[-3 pop]]", Run("[[swap -3 pop dup]]"));
Assert.Equal("[[] R<Void>[-3 pop]]", Run("[[dup / pop < swap -3 pop dup dup]]"));
Assert.Equal("[]", ReorderInterpreter.RunReorderPost("[]".ToStack()).ToRepr());
Assert.Equal("[[]]", ReorderInterpreter.RunReorderPost("[[]]".ToStack()).ToRepr());
Assert.Equal("[[-3 pop]]", Reorder("[[dup / pop < swap -3 pop dup dup]]"));
}
public void TestReorder()
{
interpreter = reorderInterpreter;
var d0 = "[[2 a 1 +]]".ToStack();
var d1 = interpreter.Eval(d0);
Assert.Equal("[[a 1 +] 2]".ToStack(), d1);
var d2 = interpreter.Eval(d1);
Assert.Equal("[[1 +] a 2]".ToStack(), d2);
var d3 = interpreter.Eval(d2);
Assert.Equal("[[+] 1 a 2]".ToStack(), d3);
var d4 = interpreter.Eval(d3);
// Assert.Equal(interpreter.ParseWithResolution("[[+ a ] 1 2]"), d4);
Assert.Equal("[[+ a] 1 2]", interpreter.StackToString(d4));
// var d4b = "[[' reorder run] [[+ a ] 1 2] []]".ToStack();
// var d4b = "[[reorder] [[+ a ] 1 2] []]".ToStack();
// var d5 = interpreter.Eval(d4b);
Assert.Equal("[[a] R<int>[2 1 +]]",
Eval("[[+ a ] 1 2]"));
var e1 = interpreter.Eval("[[+ a ] 1 2]".ToStack());
Assert.Equal("[[a] R<int>[2 1 +]]",
e1.ToRepr());
var s = e1;
Assert.Equal("[[a] R<int>[2 1 +]]",
s.ToRepr());
var e2 = ReorderInterpreter.ReorderPost(s);
Assert.Equal("[[2 1 + a]]",
e2.ToRepr());
// R<T>[1,2,3] is not parsing properly.
// Assert.Equal("[[] [[a] R<System.Int32> [2 1 +]]]",
// Eval("[[reorder-post] [[] a R<System.Int32> [2 1 +]]]"));
// Assert.Equal("[[] [[a] R<System.Int32> [2 1 +]]]",
// Eval("[[reorder-post] [[a] R<System.Int32> [2 1 +]]]"));
// var d6 = interpreter.Eval(d5);
// Assert.Equal("[[2 1 +] [[] a]]".ToStack(), d6);
}
public InterpreterTestUtil()
{
// Maybe I should do these lazily.
nonstrictInterpreter = new NonstrictInterpreter();
strictInterpreter = new StrictInterpreter();
reorderInterpreter = new ReorderInterpreter();
cleanInterpreter = new Interpreter();
typeInterpreter = new TypeInterpreter();
cleanInterpreter.instructions.Clear();
interpreter = nonstrictInterpreter;
// With InstructionFunc you have to do all your own error handling.
interpreter.instructions["add"]
= strictInterpreter.instructions["add"]
= new InstructionFunc(stack => {
if (stack.Count < 2)
{
return(stack);
}
object a, b;
a = stack.Pop();
if (!(a is int))
{
var code = new Stack();
code.Push(a);
code.Push(new Symbol("add"));
stack.Push(new Continuation(code));
return(stack);
}
b = stack.Pop();
if (!(b is int))
{
var code = new Stack();
code.Push(b);
code.Push(new Symbol("add"));
stack.Push(a);
stack.Push(new Continuation(code));
return(stack);
}
stack.Push((int)a + (int)b);
return(stack);
});
}
