public void TestFor()
{
for (int i = 0; i < testForStatements.Length; ++i)
{
var main = new Interpreter.Sequence();
var queue = new List <string>();
queue.AddRange(testForStatements[i]);
int line = 0;
while (line < queue.Count)
{
line = main.Execute(queue, line);
}
switch (resultForRuns[i].GetType().Name)
{
case "Double": Assert.AreEqual((Double)resultForRuns[i], (Double)main.GetNamedValue("sum"), 0.05);
break;
default: Assert.AreEqual(resultForRuns[i], main.GetNamedValue("sum"));
break;
}
}
}
public static void Declare
(Interpreter.Sequence receiver,
string line,
string key,
bool read,
bool write,
object payload,
Dictionary <string, Named> table = null,
string typename = "")
{
if (String.IsNullOrWhiteSpace(typename))
{
if (table == null)
{
AddDynamicNamedValue(receiver.Names, key, new Named.Value(payload, read, write), line);
}
else
{
AddNonStandardNamedValue(receiver.Names, key, new Named.Reference(table, (string)payload, read, write), line);
}
}
else
{
if (table == null)
{
AddNonStandardNamedValue(receiver.Names, key, new Named.Static.Value(typename, payload, read, write), line);
}
else
{
AddNonStandardNamedValue(receiver.Names, key, new Named.Static.Reference(typename, table, (string)payload, read, write), line);
}
}
}
public static void Declare(Interpreter.Sequence receiver, string line)
{
string op = "", key = "", typename = "", expression = "";
bool read = true, write = true, referential = false;
ParseDeclaration(line, ref key, ref read, ref write, ref referential, ref typename, ref op, ref expression);
if (op.Equals(Operators.novelty_declare))
{
if (key.ToLower().Equals("war"))
{
if (Novelty.Tables.Sovereigns.Contains(expression))
{
Console.WriteLine("War were declared.");
}
else
{
Console.WriteLine("The expression \"" + expression + "\" does not name a sovereign state, you twat.");
}
}
}
VerifyRightToLeftOperator(op);
Declare(receiver, line, key, read, write, referential ? receiver.Names.GetTable(expression) : null, typename, expression);
}
public void TestParseGroup()
{
var main = new Interpreter.Sequence();
for (int i = 0; i < testGroups.Length; ++i)
{
Assert.AreEqual(resultGroups[i], main.ParseGroup(testGroups[i]));
}
}
public void TestParseExpression()
{
var main = new Interpreter.Sequence();
for (int i = 0; i < testExpressions.Length; ++i)
{
Assert.AreEqual(resultExpressions[i], main.Expression(testExpressions[i]));
}
}
public Interpreter.Sequence TestAssignTo()
{
var main = new Interpreter.Sequence();
for (int i = 0; i < testAssignments.Length; ++i)
{
Verbs.AssignTo(main, testAssignments[i]);
Assert.AreEqual(resultAssignValues[i], main.GetNamedValue(resultAssignNames[i]));
}
return(main);
}
public void TestParseList()
{
var main = new Interpreter.Sequence();
ArrayList list;
for (int i = 0; i < testLists.Length; ++i)
{
list = main.ParseList(testLists[i]);
for (int j = 0; j < list.Count; ++j)
{
Assert.AreEqual(resultLists[i][j], list[j]);
}
}
}
public static void GoToAssignmentOrDeclaration(Interpreter.Sequence receiver, string line)
{
try
{
if (Operators.permissionops.Contains(Verbs.GetVerb(line)))
{
throw new Exception();
}
AssignTo(receiver, line);
}
catch
{
Declare(receiver, line);
}
}
public void TestFormatExceptions()
{
var main = new Interpreter.Sequence();
for (int i = 0; i < formatTests.Length; ++i)
{
try
{
main.Run(formatTests[i]);
}
catch (Exception e)
{
Assert.AreEqual(formatResults[i], e.Message);
}
}
}
public void TestDivideByZeroExceptions()
{
var main = new Interpreter.Sequence();
for (int i = 0; i < overZeroTests.Length; ++i)
{
try
{
main.Run(overZeroTests[i]);
}
catch (Exception e)
{
Assert.AreEqual(overZeroResult, e.Message);
}
}
}
public void TestPermissionDeniedExceptions()
{
var main = new Interpreter.Sequence();
for (int i = 0; i < constTests.Length; ++i)
{
try
{
main.Run(constTests[i]);
}
catch (Exception e)
{
Assert.AreEqual(constResult, e.Message);
}
}
}
public void TestIndexOutOfBoundsExceptions()
{
var main = new Interpreter.Sequence();
for (int i = 0; i < indexTests.Length; ++i)
{
try
{
main.Run(indexTests[i]);
}
catch (Exception e)
{
Assert.AreEqual(indexResults[i], e.Message);
}
}
}
public void TestRemainderFrom()
{
var main = new Interpreter.Sequence();
for (int i = 0; i < assignHighComposites.Length; ++i)
{
Verbs.AssignTo(main, assignHighComposites[i]);
}
for (int i = 0; i < testRemainders.Length; ++i)
{
Verbs.RemainderFrom(main, testRemainders[i]);
Assert.AreEqual(resultRemainders[i], main.GetNamedValue(numerics[i]));
}
}
public static void CombineWith(Interpreter.Sequence receiver, string line, BinaryOperation Combine)
{
string left = "", op = "", right = "";
if (Interpreter.Sequence.SplitTrinomial(ref left, ref op, ref right, line, Operators.assignops, Patterns.getbinaryop))
{
if (Operators.right_to_left.Contains(op))
{
receiver.ParseLeftValueExpression(left, Combine(receiver.Expression(left), receiver.Expression(right)));
}
else if (Operators.left_to_right.Contains(op))
{
receiver.ParseLeftValueExpression(right, Combine(receiver.Expression(right), receiver.Expression(left)));
}
}
else
{
throw new FormatException("Not a valid assign-statement.");
}
}
public void TestSplitAndLevel()
{
var main = new Interpreter.Sequence();
int lvl;
string verb = "", complement = "";
for (int i = 0; i < testLines.Length; ++i)
{
lvl = Interpreter.Sequence.GetLevel(testLines[i]);
Verbs.SplitSentence(testLines[i], ref verb, ref complement);
main.MoveScope(lvl);
Assert.AreEqual(resultLevels[i], lvl);
Assert.AreEqual(resultLevels[i], main.Levels);
Assert.AreEqual(resultVerbs[i], verb);
Assert.AreEqual(resultComplements[i], complement);
}
}
public void TestWhile()
{
var queue = new List <string>();
queue.AddRange(testWhileProcess.Split('\n'));
for (int i = 0; i < testWhileDeclarations.Length; ++i)
{
var main = new Interpreter.Sequence();
var testQueue = new List <string>();
testQueue.Add(testWhileDeclarations[i]);
testQueue.AddRange(queue);
int line = 0;
while (line < testQueue.Count)
{
line = main.Execute(testQueue, line);
}
Assert.AreEqual(resultWhileRuns[i], main.GetNamedValue("counter"));
}
}
public static void CallProcess(Interpreter.Sequence receiver, string line)
{
line = line.Trim();
if (String.IsNullOrEmpty(line))
{
throw new FormatException("Not a valid expression.");
}
// "FunctionName(arg1, arg2, arg3)"
string first = MicroRegex.Match.NextOuterGroup(line).Value;
// first : "FunctionName"
// secnd : ""
if (Regex.IsMatch(first, Patterns.getname))
{
string secnd = MicroRegex.Match.NextOuterGroup(line.Substring(first.Length)).Value;
// secnd : "(arg1, arg2, arg3)"
Match argsCapture = Regex.Match(secnd, Patterns.getargs);
if (argsCapture.Success)
{
// argsCapture.Value : "arg1, arg2, arg3"
receiver.LookUpFunction(first.TrimEnd(), receiver.ParseList(argsCapture.Value.Trim()));
}
else
{
throw new Exception("Syntax Error: Not a valid process call.");
}
}
}
public static void RemainderFrom(Interpreter.Sequence receiver, string line)
{
CombineWith(receiver, line, Algorithms.Arithmetic.Remainder);
}
public static void SubtractFrom(Interpreter.Sequence receiver, string line)
{
CombineWith(receiver, line, Algorithms.Arithmetic.Difference);
}
public static void ReturnValue(Interpreter.Sequence receiver, string line)
{
throw new Return(receiver.Expression(line));
}
public static void ErrorLine(Interpreter.Sequence receiver, string line)
{
Console.Error.WriteLine(receiver.Expression(line));
}
public static void OutputLine(Interpreter.Sequence receiver, string line)
{
Console.WriteLine(String.IsNullOrWhiteSpace(line) ? "" : receiver.Expression(line));
}
public static void Output(Interpreter.Sequence receiver, string line)
{
Console.Write(receiver.Expression(line));
}
public static void InputLine(Interpreter.Sequence receiver, string line)
{
receiver.ParseLeftValueExpression(line, Console.ReadLine());
}
public static void Decrement(Interpreter.Sequence receiver, string line)
{
receiver.ParseLeftValueExpression(line, Algorithms.Arithmetic.Difference(receiver.Expression(line), 1L));
}
public static void Release(Interpreter.Sequence receiver, string line)
{
receiver.Names.Remove(line.Trim());
}
public static void MultiplyBy(Interpreter.Sequence receiver, string line)
{
CombineWith(receiver, line, Algorithms.Arithmetic.Product);
}
public static void DivideBy(Interpreter.Sequence receiver, string line)
{
CombineWith(receiver, line, Algorithms.Arithmetic.Quotient);
}
public static object Call(Interpreter.Sequence sender, string name, List <object> arguments)
{
Definition newProcess = Get(name, arguments);
int lineNumber = newProcess.LineNumber;
List <string> script = Transcript.Table[newProcess.Path];
int startingLvl = Interpreter.Sequence.GetLevel(script[lineNumber]);
List <Parameter> parameters = ParseHeading(script, ref lineNumber);
var receiver = new Interpreter.Sequence();
Dictionary <string, Named> table;
for (int i = 0; i < parameters.Count; ++i)
{
if (parameters[i].referential)
{
try
{
table = sender.Names.GetTable((string)arguments[i]);
}
catch (Exception)
{
throw new Exception("Failed to get a reference for a bidirectional parameter. Are you missing a 'ref' keyword?");
}
}
else
{
table = null;
}
Verbs.Declare(receiver,
parameters[i].key,
parameters[i].key,
parameters[i].readable,
parameters[i].writeable,
arguments[i],
table,
parameters[i].typename);
}
try
{
while (lineNumber < script.Count)
{
if (String.IsNullOrWhiteSpace(script[lineNumber]))
{
lineNumber = lineNumber + 1;
}
else if (Interpreter.Sequence.GetLevel(script[lineNumber]) > startingLvl)
{
lineNumber = receiver.Execute(script, lineNumber);
}
else
{
break;
}
}
}
catch (Return r)
{
if (Operators.returnvoid.Contains(newProcess.ReturnType))
{
if (r.Payload == null)
{
throw new Exception("Line " + (lineNumber + 1) + ": Syntax Error: Returning 'null' from a process that returns void.");
}
throw new Exception("Line " + (lineNumber + 1) + ": Syntax Error: Returning a '" + r.Payload.GetType().Name + "' from a process that returns void.");
}
if (r.Payload != null && !r.Payload.GetType().Name.Equals(newProcess.ReturnType))
{
throw new Exception("Line " + (lineNumber + 1) + ": Type Mismatch: Returning a '" + r.Payload.GetType().Name + "' from a process that returns '" + newProcess.ReturnType + "'.");
}
return(r.Payload);
}
if (!Operators.returnvoid.Contains(newProcess.ReturnType))
{
throw new Exception("Line " + (newProcess.LineNumber + 1) + ": Syntax Error: No return at the end of non-void returning process.");
}
return(null);
}
public static void Clear(Interpreter.Sequence receiver, string line)
{
receiver.ParseLeftValueExpression(line, null);
}
