private object InterpretProcedureCall(ProcedureCallNode node)
{
var procedure = ResolveProcedure(node.Name);
if (procedure is CustomProcedureInfo)
{
var customProcedure = procedure as CustomProcedureInfo;
var memorySpace = new MemorySpace(memory);
for (int i = 0; i < customProcedure.Arguments.Length; i++)
{
memorySpace.Set(customProcedure.Arguments[i], InterpretNode(node.ArgumentExpressions[i]));
}
PushMemorySpace(memorySpace);
var result = Interpret(customProcedure.Tokens);
PopMemorySpace();
return(result);
}
else if (procedure is BuiltInProcedure)
{
var builtInProcedure = procedure as BuiltInProcedure;
var arguments = node.ArgumentExpressions.Select(arg => InterpretNode(arg)).ToArray();
var context = new ProcedureCallContext()
{
GlobalMemory = globalMemory,
CallToken = node.Name
};
return(builtInProcedure.Implementation(context, arguments));
}
throw new Exception($"Unknown procedure type {procedure}");
}
public override string VisitProcedureCall(ProcedureCallNode procedureCall)
{
var param = "";
if (procedureCall.Parameters.Any())
{
foreach (var procedureCallParameter in procedureCall.Parameters)
{
param += VisitNode(procedureCallParameter);
param += ",";
}
param = param.Remove(param.Length - 1);
}
if (procedureCall.ProcedureName.ToUpper() == "WRITELN")
{
var assembly = "using System;";
if (_assembliesCalled.Contains(assembly) != true)
{
_assembliesCalled.Add(assembly);
}
return($"{AddSpaces()}Console.WriteLine({param})");
}
if (procedureCall.ProcedureName.ToUpper() == "READLN")
{
var assembly = "using System;";
if (_assembliesCalled.Contains(assembly) != true)
{
_assembliesCalled.Add(assembly);
}
if (procedureCall.Parameters.Count > 1)
{
throw new SemanticException(ErrorCode.Runtime, procedureCall.Token, "cannot have more than one parameter");
}
if (procedureCall.Parameters.Any())
{
return($"{AddSpaces()}{param} = Console.ReadLine()");
}
return($"{AddSpaces()}Console.ReadLine()");
}
return($"{AddSpaces()}{procedureCall.ProcedureName}({param})");
}
public virtual T VisitProcedureCall(ProcedureCallNode procedureCall)
{
throw new NotImplementedException();
}
public string VisitProcedureCall(ProcedureCallNode procedureCall)
{
throw new NotImplementedException();
}
public AddressNode VisitProcedureCall(ProcedureCallNode procedureCall)
{
throw new System.NotImplementedException();
}
private Node ParseFactor()
{
var position = tokens.CurrentToken.Location;
if (tokens.CurrentToken.Type == TokenType.ParenthesisLeft)
{
tokens.Eat(TokenType.ParenthesisLeft);
Node node;
if (tokens.CurrentToken.Type == TokenType.Identifier)
{
// Vararg procedure call
var name = tokens.Eat(TokenType.Identifier);
var procedure = ResolveProcedure(name);
var argumentExpressions = new List <Node>();
while (tokens.CurrentToken.Type != TokenType.ParenthesisRight)
{
argumentExpressions.Add(ParseExpression());
}
node = new ProcedureCallNode(position)
{
Name = name, ArgumentExpressions = argumentExpressions.ToArray()
};
}
else
{
node = ParseExpression();
}
tokens.Eat(TokenType.ParenthesisRight);
return(node);
}
else if (tokens.CurrentToken.Type == TokenType.BracketLeft)
{
// List
tokens.Eat(TokenType.BracketLeft);
var values = new ListVariable();
while (tokens.CurrentToken.Type != TokenType.BracketRight)
{
values.Add(tokens.Eat().LiteralValue);
}
tokens.Eat(TokenType.BracketRight);
return(new ListNode(position)
{
Values = values
});
}
else if (tokens.CurrentToken.Type == TokenType.Integer)
{
var token = tokens.Eat(TokenType.Integer);
return(new IntegerNode(position)
{
Value = Convert.ToInt32(token.Value)
});
}
else if (tokens.CurrentToken.Type == TokenType.True || tokens.CurrentToken.Type == TokenType.False)
{
var token = tokens.Eat();
return(new BooleanNode(position)
{
Value = token.Value.Equals("welwaar", StringComparison.CurrentCultureIgnoreCase)
});
}
else if (tokens.CurrentToken.Type == TokenType.Colon)
{
tokens.Eat(TokenType.Colon);
var variableName = tokens.Eat(TokenType.Identifier);
return(new VariableNode(position)
{
Name = variableName
});
}
else if (tokens.CurrentToken.Type == TokenType.StringLiteral)
{
var value = tokens.Eat(TokenType.StringLiteral);
return(new StringLiteralNode(position)
{
Value = value
});
}
else if (tokens.CurrentToken.Type == TokenType.Identifier)
{
var name = tokens.Eat(TokenType.Identifier);
var procedure = ResolveProcedure(name);
var argumentExpressions = new List <Node>();
for (int i = 0; i < procedure.Arguments.Length; i++)
{
argumentExpressions.Add(ParseExpression());
}
return(new ProcedureCallNode(position)
{
Name = name, ArgumentExpressions = argumentExpressions.ToArray()
});
}
throw new ScriptException($"Onverwachte invoer: {tokens.CurrentToken}", tokens.CurrentToken);
}
public SymConst Visit(ProcedureCallNode node)
{
throw EvalException();
}
