public void RoutesSmallerThanPatternTestFailure()
{
var expectedResult = new TokenizedLine(new List <string>(), LineType.InvalidLine);
(new Tuple <string, TokenizedLine>[] {
Tuple.Create("The number of different routes from C to C with a distance of less than 30A.", expectedResult),
Tuple.Create("The number of different routes from CV to C with a distance of less than 30.", expectedResult)
})
.ForEach(l => assertPattern(l.Item1, l.Item2));
}
public void MaxNumberOfStopsPatternTestFailure()
{
var expectedResult = new TokenizedLine(new List <string>(), LineType.InvalidLine);
(new Tuple <string, TokenizedLine>[] {
Tuple.Create("The number of trips starting at C and ending at CA with a maximum of 3 stops.", expectedResult),
Tuple.Create("The number of trips stating at C and ending at B with a maximum of 55 stops.", expectedResult)
})
.ForEach(l => assertPattern(l.Item1, l.Item2));
}
public void ShortestPathPatternTestFailure()
{
var expectedResult = new TokenizedLine(new List <string>(), LineType.InvalidLine);
(new Tuple <string, TokenizedLine>[] {
Tuple.Create("The length of the shortest route (in terms of distance to travel) from AS to CX.", expectedResult),
Tuple.Create("The length of the shortest roue (in terms of distance to travel) from A to C.", expectedResult)
})
.ForEach(l => assertPattern(l.Item1, l.Item2));
}
public void ExactNumberOfStopsPatternTestFailure()
{
var expectedResult = new TokenizedLine(new List <string>(), LineType.InvalidLine);
(new Tuple <string, TokenizedLine>[] {
Tuple.Create("The number of trips starting at AB and ending at C with exactly 7 stops.", expectedResult),
Tuple.Create("The number of trips starting at D and ending at E with exatly 45 stops.", expectedResult)
})
.ForEach(l => assertPattern(l.Item1, l.Item2));
}
/// <summary>
/// Definitions can be declared anywhere in the doc and aren't related to each other
/// except that duplicate definitions are invalid.
/// </summary>
/// <param name="stack"></param>
/// <param name="tokenizedLine"></param>
private void CompileDefinition(
CompilerLog log,
StackObject stack,
TokenizedLine tokenizedLine)
{
SyntaxTree tree = tokenizedLine.SyntaxTree;
switch (tree.DeclaredType)
{
case DeclaredType.Narrative:
if (stack.Narrative != null)
{
log.Error(tokenizedLine, $"Cannot define additional narrative \"{tree.AssignedValue}\". Narrative \"{stack.Narrative.Name}\" already defined.");
}
else
{
stack.Narrative = new Narrative(tree.AssignedValue.ToString());
}
break;
case DeclaredType.Character:
var characterName = tree.AssignedValue.ToString();
var characterToAdd = new Character(characterName);
if (stack.Characters.Contains(characterToAdd))
{
log.Error(tokenizedLine, $"Duplicate Character definition for \"{characterName}\".");
}
else
{
stack.Characters.Add(characterToAdd);
}
break;
case DeclaredType.Setting:
var settingName = tree.AssignedValue.ToString();
var setting = new Setting(settingName);
if (stack.Settings.Contains(setting))
{
log.Error(tokenizedLine, $"Duplicate Setting definition for \"{setting.Name}\".");
}
else
{
stack.Settings.Add(setting);
}
break;
default:
log.Error(tokenizedLine, $"Cannot define declared type {tree.DeclaredType}");
break;
}
}
public void GraphPatternTestFailure()
{
var expectedResult = new TokenizedLine(new List <string>(), LineType.InvalidLine);
(new Tuple <string, TokenizedLine>[] {
Tuple.Create("Graph: AB5, BC4, CD8, DC8, DE6, AD5, CE2 EB3, AE7", expectedResult),
Tuple.Create("Graph: AB5,", expectedResult),
Tuple.Create("Grah: ", expectedResult),
Tuple.Create("Graph: AD5, CE2, EAB3, AE7", expectedResult)
})
.ForEach(l => assertPattern(l.Item1, l.Item2));
}
private void assertPattern(string line, TokenizedLine tokens)
{
RegexEngine engine = new RegexEngine();
var tokenizedLine = engine.ExtractTokens(line);
Assert.AreEqual(tokenizedLine.Type, tokens.Type);
Assert.AreEqual(tokenizedLine.Tokens.Count, tokens.Tokens.Count);
for (int i = 0; i < tokenizedLine.Tokens.Count; i++)
{
Assert.AreEqual(tokens.Tokens[i], tokenizedLine.Tokens[i]);
}
}
public void DistanceOfRoutePatternTestFailure()
{
var expectedResult = new TokenizedLine(new List <string>(), LineType.InvalidLine);
(new Tuple <string, TokenizedLine>[] {
Tuple.Create("The distance of the route A-B- C", expectedResult),
Tuple.Create("The distance of the route A.", expectedResult),
Tuple.Create("The distance of the route.", expectedResult),
Tuple.Create("The distance of the route ADFDFD - D - C.", expectedResult),
Tuple.Create("The distance of the sdfa route A - D.", expectedResult),
Tuple.Create("The distance of the route A - 3 - 8 - C - D.", expectedResult)
})
.ForEach(l => assertPattern(l.Item1, l.Item2));
}
private void CompileExit(
CompilerLog log,
Compilation.StackFrame currentFrame,
TokenizedLine tokenizedLine)
{
SyntaxTree tree = tokenizedLine.SyntaxTree;
switch (tree.DeclaredType)
{
case DeclaredType.Act:
if (currentFrame.Act == null)
{
log.Warning(tokenizedLine, $"Attempted to exit act but currently not in an act.");
}
else
{
log.Debug(tokenizedLine, $"Exiting act \"{currentFrame.Act.Name}\"");
currentFrame.Act = null;
}
break;
case DeclaredType.Scene:
if (currentFrame.Scene == null)
{
log.Warning(tokenizedLine, $"Attempted to exit scene but currently not in a scene.");
}
else if (currentFrame.Scene.Characters.Count != 0)
{
log.Warning(tokenizedLine, "Exiting scene with characters present will exeunt all characters. Did you mean to do this?");
currentFrame.Scene = null;
}
else
{
log.Debug(tokenizedLine, $"Exiting scene \"{currentFrame.Scene.Name}\"");
currentFrame.Scene = null;
}
break;
case DeclaredType.Character:
var characterName = tree.AssignedValue.ToString();
if (currentFrame.Scene == null)
{
log.Error(tokenizedLine, $"Cannot exit character outside of scene. Please enter a scene first.");
}
else
{
Character characterToExit = currentFrame.Scene.Characters
.SingleOrDefault(t => t.Name == characterName);
if (characterToExit == null)
{
log.Warning(tokenizedLine, $"Attempted to exit character \"{characterName}\" who was not present in scene.");
}
else
{
log.Debug(tokenizedLine, $"Exiting character \"{characterName}\"");
currentFrame.Scene.Characters.Remove(characterToExit);
}
}
break;
case DeclaredType.Setting:
var settingName = tree.AssignedValue.ToString();
if (currentFrame.Setting == null)
{
log.Error(tokenizedLine, $"Attempted to exit setting \"{settingName}\" which was never entered.");
}
else if (currentFrame.Setting.Name != settingName)
{
log.Error(tokenizedLine, $"Attempted to exit setting \"{settingName}\", but expected to exit current setting with name \"{currentFrame.Setting.Name}\".");
}
else
{
log.Debug(tokenizedLine, $"Exiting setting \"{settingName}\"");
currentFrame.Setting = null;
}
break;
default:
throw new InternalCompilerException($"Cannot exit declared type {tree.DeclaredType}");
}
}
private void CompileEntrance(
StackObject objectDefinitions,
CompilerLog log,
Compilation.StackFrame currentFrame,
TokenizedLine tokenizedLine)
{
SyntaxTree tree = tokenizedLine.SyntaxTree;
switch (tree.DeclaredType)
{
case DeclaredType.Act:
var actName = tree.AssignedValue.ToString();
if (currentFrame.Act != null)
{
log.Error(tokenizedLine, $"Cannot enter act with name \"{actName}\" when already in act \"{currentFrame.Act.Name}\".");
}
else
{
var actToEnter = new Act(actName);
if (objectDefinitions.Acts.Contains(actToEnter))
{
log.Error(tokenizedLine, $"Cannot re-enter act with name \"{actName}\".");
}
else
{
objectDefinitions.Acts.Add(actToEnter);
currentFrame.Act = actToEnter;
}
}
break;
case DeclaredType.Scene:
var sceneName = tree.AssignedValue.ToString();
if (currentFrame.Scene != null)
{
log.Error(tokenizedLine, $"Cannot enter scene with name \"{sceneName}\" when already in scene \"{currentFrame.Scene.Name}\".");
}
else
{
var sceneToEnter = new Scene(sceneName);
if (objectDefinitions.Scenes.Contains(sceneToEnter))
{
log.Error(tokenizedLine, $"Cannot re-enter scene with name \"{sceneName}\".");
}
else
{
log.Debug(tokenizedLine, $"Entered scene \"{sceneName}\"");
objectDefinitions.Scenes.Add(sceneToEnter);
currentFrame.Scene = sceneToEnter;
}
}
break;
case DeclaredType.Character:
var characterName = tree.AssignedValue.ToString();
var character = objectDefinitions.Characters.SingleOrDefault(t => t.Name == characterName);
if (character == null)
{
log.Error(tokenizedLine, $"Cannot enter undefined character \"{characterName}\".");
}
else
{
var currentScene = currentFrame.Scene;
if (currentScene == null)
{
log.Error(tokenizedLine, $"Cannot enter character \"{characterName}\" outside of a scene. Please enter a scene first.");
}
else
{
log.Debug(tokenizedLine, $"Entered Character \"{characterName}\"");
currentScene.Characters.Add(character);
}
}
break;
case DeclaredType.Setting:
var settingName = tree.AssignedValue.ToString();
var setting = objectDefinitions.Settings.SingleOrDefault(t => t.Name == settingName);
if (setting == null)
{
log.Error(tokenizedLine, $"Cannot enter undefined setting \"{settingName}\".");
}
else
{
if (currentFrame.Setting != null)
{
log.Warning(tokenizedLine, $"Switching setting to \"{settingName}\" from current setting \"{currentFrame.Setting.Name}\".");
}
log.Debug(tokenizedLine, $"Entered setting \"{settingName}\"");
currentFrame.Setting = setting;
}
break;
default:
throw new InternalCompilerException($"Cannot enter declared type {tree.DeclaredType}");
}
}
public void Error(TokenizedLine tokenizedLine, string message) => Error(tokenizedLine.Line, tokenizedLine.LineNumber, tokenizedLine.Line?.Length ?? 0, message);
public void Warning(TokenizedLine tokenizedLine, string message) => Warning(tokenizedLine.Line, tokenizedLine.LineNumber, tokenizedLine.Line?.Length ?? 0, message);
