public void TestDetermineInputAndOutput3()
{
UniqueVariable.Clear();
interpreter = typeInterpreter;
var s = "[[if typeof(int) + typeof(char)]]".ToStack();
var _if
= new DetermineTypesInstruction("[bool 'a 'a]",
"['a]")
{
getType = o => o is Type t ? t : o.GetType()
};
var add
= new DetermineTypesInstruction("[int int]",
"[int]")
{
getType = o => o is Type t ? t : o.GetType()
};
interpreter.instructions["if"] = _if;
interpreter.instructions["+"] = add;
var s2 = interpreter.Run(s);
Assert.Equal("[[] char int { a0 -> int } ['a0 'a0 bool]]", s2.ToRepr());
s2.Pop();
var(consumes, produces) = TypeInterpreter.ConsumesAndProduces(s2);
Assert.Equal("[bool int int]", consumes.ToRepr());
Assert.Equal("[int char]", produces.ToRepr());
}
public void TestNoSwap()
{
interpreter = typeInterpreter;
UniqueVariable.Clear();
var s = "[[typeof(int) typeof(char) ]]";
Assert.Equal("[[] char int]", Run(s));
var s2 = lastRun;
s2.Pop();
var(consumes, produces) = TypeInterpreter.ConsumesAndProduces(s2);
Assert.Equal("[]", consumes.ToRepr());
Assert.Equal("[int char]", produces.ToRepr());
}
public void TestSwap2()
{
interpreter = typeInterpreter;
UniqueVariable.Clear();
var s = "[[swap]]";
Assert.Equal("[[] 'a0 'b1 ['b1 'a0]]", Run(s));
var s2 = lastRun;
s2.Pop();
var(consumes, produces) = TypeInterpreter.ConsumesAndProduces(s2);
Assert.Equal("['a0 'b1]", consumes.ToRepr());
Assert.Equal("['b1 'a0]", produces.ToRepr());
}
public void TestTypeCheckDupDupWithVars3()
{
interpreter = typeInterpreter;
UniqueVariable.Clear();
var s = "[[dup typeof(char) dup]]";
Assert.Equal("[[] 'a1 'a1 { a1 -> char } 'a0 'a0 ['a0]]", Run(s));
var s2 = lastRun;
s2.Pop();
var(consumes, produces) = TypeInterpreter.ConsumesAndProduces(s2);
Assert.Equal("['a0]", consumes.ToRepr());
Assert.Equal("['a0 'a0 char char]", produces.ToRepr());
}
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);
});
}
public void TestTypeCheckDupInterp()
{
interpreter = typeInterpreter;
UniqueVariable.Clear();
var s = "[[typeof(int) dup]]";
// var dup
// = new DetermineTypesInstruction("['a]",
// "['a 'a]")
// { getType = o => o is Type t ? t : o.GetType() };
// interpreter.instructions["dup"] = dup;
Assert.Equal("[[] 'a0 'a0 { a0 -> int }]", Run(s));
var s2 = lastRun;
s2.Pop();
var(consumes, produces) = TypeInterpreter.ConsumesAndProduces(s2);
Assert.Equal("[]", consumes.ToRepr());
Assert.Equal("[int int]", produces.ToRepr());
}
public void TestTypeCheckDupDupWithVars2()
{
interpreter = cleanInterpreter;
UniqueVariable.Clear();
var s = "[[dup typeof(char) dup]]";
var dup
= new DetermineTypesInstruction("['a]",
"['a 'a]")
{
getType = o => o is Type t ? t : o.GetType()
};
interpreter.instructions["dup"] = dup;
Assert.Equal("[[] 'a1 'a1 { a1 -> char } 'a0 'a0 ['a0]]", Run(s));
var s2 = lastRun;
s2.Pop();
var(consumes, produces) = TypeInterpreter.ConsumesAndProduces(s2);
Assert.Equal("['a0]", consumes.ToRepr());
Assert.Equal("['a0 'a0 char char]", produces.ToRepr());
}