public void RefreshOutputs()
{
var outputs = new VariableDefinitionList();
GetOutputs(outputs);
Outputs = RefreshDefinitions(outputs);
}
public void RefreshInputs()
{
var inputs = new VariableDefinitionList();
GetInputs(inputs);
Inputs = RefreshDefinitions(inputs);
}
private static void ComputeProvidedCondition(VariableDefinitionList definedVariables, IfStatementFlags ifStatementFlags)
{
var leftSideVariableValue = definedVariables.ExtractValue <int>(ifStatementFlags.LeftSideVariable);
var rightSideVariableValue = definedVariables.ExtractValue <int>(ifStatementFlags.RightSideVariable);
switch (ifStatementFlags.ConditionalOperator)
{
case "<":
ifStatementFlags.ConditionIsTrue = leftSideVariableValue < rightSideVariableValue;
break;
case "<=":
ifStatementFlags.ConditionIsTrue = leftSideVariableValue <= rightSideVariableValue;
break;
case "==":
ifStatementFlags.ConditionIsTrue = leftSideVariableValue == rightSideVariableValue;
break;
case "!=":
ifStatementFlags.ConditionIsTrue = leftSideVariableValue != rightSideVariableValue;
break;
case ">":
ifStatementFlags.ConditionIsTrue = leftSideVariableValue > rightSideVariableValue;
break;
case ">=":
ifStatementFlags.ConditionIsTrue = leftSideVariableValue >= rightSideVariableValue;
break;
}
}
public Node VarDefList()
{
var varDefList = new VariableDefinitionList();
while (CurrentToken == TokenCategory.VAR)
{
varDefList.Add(VarDef());
}
return(varDefList);
}
public override void Setup(object obj)
{
Fields.Clear();
var graph = obj as Graph;
var locals = new VariableDefinitionList();
foreach (var local in locals)
{
Fields.Add(new DefinitionAutocompleteItem(local));
}
}
private VariableDefinitionList RefreshDefinitions(VariableDefinitionList requests)
{
var results = new VariableDefinitionList();
foreach (var request in requests)
{
UpdateDefinition(results, request, true);
}
foreach (var existing in Inputs)
{
UpdateDefinition(results, existing, false);
}
return(results);
}
private void UpdateDefinition(VariableDefinitionList definitions, VariableDefinition definition, bool add)
{
for (var i = 0; i < definitions.Count; i++)
{
if (definitions[i].Name == definition.Name)
{
if (!definitions[i].Definition.IsTypeLocked || (definitions[i].Definition.Type == definition.Definition.Type && !definitions[i].Definition.IsConstraintLocked))
{
definitions[i] = definition;
return;
}
}
}
if (add)
{
definitions.Add(definition);
}
}
private static void Main(string[] args)
{
var executionFailed = false;
var output = new StringBuilder();
try {
const string code = @"int a = 0;
int b = 10;
if a < b
write: a is greater than b.;
else
write: a is not greater than b.;";
var cleanedCode = CleanUpCode(code);
var tokenizedCode = TokenizeCode(cleanedCode);
var variableFlags = new VariableFlags();
var ifStatementFlags = new IfStatementFlags();
var definedVariables = new VariableDefinitionList();
foreach (var token in tokenizedCode)
{
if (token == ";")
{
variableFlags.Reset();
}
if (variableFlags.NameFounded)
{
if (!variableFlags.WasVariableAssignOperatorFound && token != "=")
{
throw new InvalidSyntaxException("If you want to assign a value into a variable, value must be followed after an equal-sign (=).");
}
if (variableFlags.WasVariableAssignOperatorFound)
{
object variableValue = token;
definedVariables.Update(variableFlags.Name, variableValue);
}
else
{
variableFlags.WasVariableAssignOperatorFound = true;
}
}
else if (variableFlags.TypeFounded)
{
variableFlags.Name = token;
definedVariables.Add(variableFlags.Type, variableFlags.Name);
}
else if (token == "int")
{
variableFlags.Type = typeof(int);
}
else if (ifStatementFlags.WriteToOutput)
{
if (token == ";")
{
ifStatementFlags.WriteToOutput = false;
}
else
{
output.Append(token + " ");
}
}
else if (ifStatementFlags.ConditionIsTrue.HasValue)
{
if (token == "else")
{
ifStatementFlags.ElseFounded = true;
continue;
}
if (ifStatementFlags.ElseFounded && !ifStatementFlags.ConditionIsTrue.Value)
{
if (token == "write:")
{
ifStatementFlags.WriteToOutput = true;
}
else
{
throw new InvalidSyntaxException(string.Format("An unrecognized token was found: {0}", token));
}
}
else
{
if (!ifStatementFlags.ElseFounded && ifStatementFlags.ConditionIsTrue.Value)
{
if (token == "write:")
{
ifStatementFlags.WriteToOutput = true;
}
else
{
throw new InvalidSyntaxException(string.Format("An unrecognized token was found: {0}", token));
}
}
}
}
else if (ifStatementFlags.IfFounded)
{
if (!ifStatementFlags.LeftSideVariableFounded)
{
if (!definedVariables.IsDeclared(token))
{
throw new UnknownVariableNameException(token);
}
ifStatementFlags.LeftSideVariable = token;
}
else if (!ifStatementFlags.ConditionalOperatorFounded)
{
if (!IsOperator(token))
{
throw new InvalidSyntaxException("A conditional operator needed when you want to compare two things.");
}
ifStatementFlags.ConditionalOperator = token;
}
else if (!ifStatementFlags.RightSideVariableFounded)
{
if (!definedVariables.IsDeclared(token))
{
throw new UnknownVariableNameException(token);
}
ifStatementFlags.RightSideVariable = token;
ComputeProvidedCondition(definedVariables, ifStatementFlags);
}
}
else if (token == "if")
{
ifStatementFlags.Reset();
ifStatementFlags.IfFounded = true;
}
else if (token == ";")
{
continue;
}
else
{
throw new InvalidSyntaxException(string.Format("An unrecognized token was found: {0}", token));
}
}
} catch (Exception e) {
executionFailed = true;
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("\n\nAn exception occurs when interpreting your code: " + e.Message);
Console.ResetColor();
}
if (executionFailed)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("\n\nExecution of code was failed.");
Console.ResetColor();
}
else
{
Console.WriteLine(output);
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("\n\nExecution of code was succeeded.");
Console.ResetColor();
}
Console.WriteLine("\n\nPress any key to exit...");
Console.ReadKey();
}
