/// <summary>
/// Initializes a new instance of the <see cref="ExpressionEvaluator"/> class.
/// </summary>
/// <param name="variableRepository">Variable repository.</param>
/// <param name="runEnvironment">Run time environment, used mostly for the current line.</param>
public ExpressionEvaluator(
IVariableRepository variableRepository,
IRunEnvironment runEnvironment)
{
_variableRepository = variableRepository;
_runEnvironment = runEnvironment;
}
/// <summary>
/// Initializes a new instance of the <see cref="Print"/> class.
/// </summary>
/// <param name="runEnvironment">Run time environment.</param>
/// <param name="expressionEvaluator">Expression evaluator.</param>
/// <param name="teletype">Output teletype to use.</param>
public Print(IRunEnvironment runEnvironment, IExpressionEvaluator expressionEvaluator, ITeletypeWithPosition teletype)
: base("PRINT", TokenClass.Statement, TokenType.Print)
{
_runEnvironment = runEnvironment;
_expressionEvaluator = expressionEvaluator;
_teletype = teletype;
}
/// <summary>
/// Executes a user defined function.
/// </summary>
/// <param name="parameter">new parameter value.</param>
/// <param name="runEnvironment">Run evironment.</param>
/// <param name="expressionEvaluator">Expression evaluator.</param>
/// <param name="variableRepository">Variable repository.</param>
/// <returns>Value of function.</returns>
public Accumulator Execute(
Accumulator parameter,
IRunEnvironment runEnvironment,
IExpressionEvaluator expressionEvaluator,
IVariableRepository variableRepository)
{
// Save the variable and program line.
var savedVariable = variableRepository.GetOrCreateVariable(VariableName, new short[] { }).GetValue();
var savedProgramLine = runEnvironment.CurrentLine;
// Change the variable to be our parameter.
variableRepository.GetOrCreateVariable(VariableName, new short[] { }).SetValue(parameter);
runEnvironment.CurrentLine = Line;
runEnvironment.CurrentLine.CurrentToken = LineToken;
// Evaluate the expression.
var returnValue = expressionEvaluator.GetExpression();
// Restore the variable and program line.
variableRepository.GetOrCreateVariable(VariableName, new short[] { }).SetValue(savedVariable);
runEnvironment.CurrentLine = savedProgramLine;
// return the value.
return(returnValue);
}
public void DefDefinesFunctionThrowsOnBadToken(int insertRemAt, string nextToken, string message)
{
var tokens = new List <IToken>
{
new Token("FN", TokenClass.Statement, TokenType.Fn),
new Token("NAME"),
new Token("(", TokenClass.Seperator, TokenType.OpenBracket),
new Token("A"),
new Token(")", TokenClass.Seperator, TokenType.CloseBracket),
new Token("=", TokenClass.Seperator, TokenType.Equal),
new Token("A"),
new Token("*", TokenClass.Seperator, TokenType.Multiply),
new Token("A"),
new Token(":", TokenClass.Seperator, TokenType.Colon)
};
tokens.Insert(insertRemAt, new Token("bang", TokenClass.Remark));
_runEnvironment = new RunEnvironment();
_variableRepository = new VariableRepository();
_expressionEvaluator = new ExpressionEvaluator(_variableRepository, _runEnvironment);
var programLine = new ProgramLine(10, tokens);
_runEnvironment.CurrentLine = programLine;
var sut = new Def(_runEnvironment, _expressionEvaluator);
Test.Throws <SyntaxErrorException>(sut.Execute);
Assert.AreEqual(nextToken, _runEnvironment.CurrentLine.NextToken().Text);
}
public void DefDefinesFunctionAndDoesntEatColon()
{
var tokens = new List <IToken>
{
new Token("FN", TokenClass.Statement, TokenType.Fn),
new Token("NAME"),
new Token("(", TokenClass.Seperator, TokenType.OpenBracket),
new Token("A"),
new Token(")", TokenClass.Seperator, TokenType.CloseBracket),
new Token("=", TokenClass.Seperator, TokenType.Equal),
new Token("A"),
new Token("*", TokenClass.Seperator, TokenType.Multiply),
new Token("A"),
new Token(":", TokenClass.Seperator, TokenType.Colon)
};
_runEnvironment = new RunEnvironment();
_variableRepository = new VariableRepository();
_expressionEvaluator = new ExpressionEvaluator(_variableRepository, _runEnvironment);
var programLine = new ProgramLine(10, tokens);
_runEnvironment.CurrentLine = programLine;
var sut = new Def(_runEnvironment, _expressionEvaluator);
sut.Execute();
Assert.AreEqual(TokenType.Colon, _runEnvironment.CurrentLine.NextToken().Seperator);
var definition = _runEnvironment.DefinedFunctions["NAME"];
Assert.AreEqual("NAME", definition.FunctionName);
Assert.AreEqual("A", definition.VariableName);
Assert.AreEqual(6, definition.LineToken);
Assert.AreEqual(programLine, definition.Line);
}
public void DefDefinesFunctionThrowsOnBadLineNumber()
{
var tokens = new List <IToken>
{
new Token("FN", TokenClass.Statement, TokenType.Fn),
new Token("NAME"),
new Token("(", TokenClass.Seperator, TokenType.OpenBracket),
new Token("A"),
new Token(")", TokenClass.Seperator, TokenType.CloseBracket),
new Token("=", TokenClass.Seperator, TokenType.Equal),
new Token("A"),
new Token("*", TokenClass.Seperator, TokenType.Multiply),
new Token("A"),
new Token(":", TokenClass.Seperator, TokenType.Colon)
};
_runEnvironment = new RunEnvironment();
_variableRepository = new VariableRepository();
_expressionEvaluator = new ExpressionEvaluator(_variableRepository, _runEnvironment);
var programLine = new ProgramLine(null, tokens);
_runEnvironment.CurrentLine = programLine;
var sut = new Def(_runEnvironment, _expressionEvaluator);
Test.Throws <IllegalDirectException>(sut.Execute);
}
/// <summary>
/// Initializes a new instance of the <see cref="Gosub"/> class.
/// </summary>
/// <param name="runEnvironment">Run time environment.</param>
/// <param name="programRepository">Program Repository.</param>
public Gosub(
IRunEnvironment runEnvironment,
IProgramRepository programRepository)
: base("GOSUB", TokenClass.Statement, TokenType.Gosub)
{
_runEnvironment = runEnvironment;
_programRepository = programRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="Del"/> class.
/// </summary>
/// <param name="runEnvironment">Run environment.</param>
/// <param name="programRepository">Program Repository.</param>
public Del(
IRunEnvironment runEnvironment,
IProgramRepository programRepository)
: base("DEL", TokenClass.Statement)
{
_runEnvironment = runEnvironment;
_programRepository = programRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="Def"/> class.
/// </summary>
/// <param name="runEnvironment">Run time environment.</param>
/// <param name="expressionEvaluator">Expression evaluator.</param>
public Def(
IRunEnvironment runEnvironment,
IExpressionEvaluator expressionEvaluator)
: base("DEF", TokenClass.Statement)
{
_runEnvironment = runEnvironment;
_expressionEvaluator = expressionEvaluator;
}
/// <summary>
/// Initializes a new instance of the <see cref="Resume"/> class.
/// </summary>
/// <param name="runEnvironment">Run time environment.</param>
/// <param name="programRepository">Program repository.</param>
public Resume(
IRunEnvironment runEnvironment,
IProgramRepository programRepository)
: base("RESUME", TokenClass.Statement)
{
_runEnvironment = runEnvironment;
_programRepository = programRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="Next"/> class.
/// </summary>
/// <param name="runEnvironment">Run time environment.</param>
/// <param name="variableRepository">Variable repository.</param>
public Next(
IRunEnvironment runEnvironment,
IVariableRepository variableRepository)
: base("NEXT", TokenClass.Statement)
{
_runEnvironment = runEnvironment;
_variableRepository = variableRepository;
}
private void SetupSut()
{
_runEnvironment = new RunEnvironment();
_mockVariableRepository = new Mock <IVariableRepository>();
_teletype = new MockTeletype();
_teletypeWithPosition = new TeletypeWithPosition(_teletype);
_expressionEvaluator = new ExpressionEvaluator(_mockVariableRepository.Object, _runEnvironment);
_sut = new Print(_runEnvironment, _expressionEvaluator, _teletypeWithPosition);
}
/// <summary>
/// Initializes a new instance of the <see cref="Dim"/> class.
/// </summary>
/// <param name="runEnvironment">Run environment.</param>
/// <param name="expressionEvaluator">Expression evaluator.</param>
/// <param name="variableRepository">Variable repository.</param>
public Dim(
IRunEnvironment runEnvironment,
IExpressionEvaluator expressionEvaluator,
IVariableRepository variableRepository)
: base("DIM", TokenClass.Statement)
{
_runEnvironment = runEnvironment;
_expressionEvaluator = expressionEvaluator;
_variableRepository = variableRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="Get"/> class.
/// </summary>
/// <param name="runEnvironment">Run time environment.</param>
/// <param name="expressionEvaluator">Expression evaluator.</param>
/// <param name="teletypeWithPosition">Teletype.</param>
public Get(
IRunEnvironment runEnvironment,
IExpressionEvaluator expressionEvaluator,
ITeletypeWithPosition teletypeWithPosition)
: base("GET", TokenClass.Statement)
{
_runEnvironment = runEnvironment;
_expressionEvaluator = expressionEvaluator;
_teletypeWithPosition = teletypeWithPosition;
}
/// <summary>
/// Initializes a new instance of the <see cref="Edit"/> class.
/// Edit command, allows editing of a program line.
/// </summary>
/// <param name="runEnvironment">Run environment.</param>
/// <param name="programRepository">Program repository</param>
/// <param name="teletype">teletype.</param>
public Edit(
IRunEnvironment runEnvironment,
IProgramRepository programRepository,
ITeletype teletype)
: base("EDIT", TokenClass.Statement)
{
_runEnvironment = runEnvironment;
_programRepository = programRepository;
_teletype = teletype;
}
/// <summary>
/// Initializes a new instance of the <see cref="Goto"/> class.
/// </summary>
/// <param name="runEnvironment">Run time environment.</param>
/// <param name="expressionEvaluator">Expression evaluator.</param>
/// <param name="programRepository">Program Repository.</param>
public Goto(
IRunEnvironment runEnvironment,
IExpressionEvaluator expressionEvaluator,
IProgramRepository programRepository)
: base("GOTO", TokenClass.Statement, TokenType.Goto)
{
_programRepository = programRepository;
_runEnvironment = runEnvironment;
_expressionEvaluator = expressionEvaluator;
}
/// <summary>
/// Initializes a new instance of the <see cref="Read"/> class.
/// </summary>
/// <param name="runEnvironment">Run time environment.</param>
/// <param name="expressionEvaluator">Expression evaluator.</param>
/// <param name="dataStatementReader">Data statement reader.</param>
public Read(
IRunEnvironment runEnvironment,
IExpressionEvaluator expressionEvaluator,
IDataStatementReader dataStatementReader)
: base("READ", TokenClass.Statement)
{
_runEnvironment = runEnvironment;
_expressionEvaluator = expressionEvaluator;
_dataStatementReader = dataStatementReader;
}
private void SetupSut()
{
_runEnvironment = new RunEnvironment();
_variableRepository = new VariableRepository();
_mockExpressionEvaluator = new Mock <IExpressionEvaluator>();
_mockTeletypeWithPosition = new Mock <ITeletypeWithPosition>();
_runEnvironment.CurrentLine = new ProgramLine(10, new List <IToken> {
});
_sut = new Get(_runEnvironment, _mockExpressionEvaluator.Object, _mockTeletypeWithPosition.Object);
}
/// <summary>
/// Initializes a new instance of the <see cref="If"/> class.
/// </summary>
/// <param name="runEnvironment">Run time environment.</param>
/// <param name="expressionEvaluator">Expression evaluator.</param>
/// <param name="programRepository">Program repository.</param>
public If(
IRunEnvironment runEnvironment,
IExpressionEvaluator expressionEvaluator,
IProgramRepository programRepository)
: base("IF", TokenClass.Statement)
{
_runEnvironment = runEnvironment;
_expressionEvaluator = expressionEvaluator;
_programRepository = programRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="Clear"/> class.
/// </summary>
/// <param name="runEnvironment">Run time environment.</param>
/// <param name="variableRepository">Variable Repository.</param>
/// <param name="dataStatementReader">Data statement reader.</param>
public Clear(
IRunEnvironment runEnvironment,
IVariableRepository variableRepository,
IDataStatementReader dataStatementReader)
: base("CLEAR", TokenClass.Statement)
{
_runEnvironment = runEnvironment;
_variableRepository = variableRepository;
_dataStatementReader = dataStatementReader;
}
/// <summary>
/// Initializes a new instance of the <see cref="On"/> class.
/// </summary>
/// <param name="runEnvironment">Run time environment.</param>
/// <param name="expressionEvaluator">Expression evaluator.</param>
/// <param name="programRepository">Program Repository.</param>
public On(
IRunEnvironment runEnvironment,
IExpressionEvaluator expressionEvaluator,
IProgramRepository programRepository)
: base("ON", TokenClass.Statement, TokenType.Gosub)
{
_runEnvironment = runEnvironment;
_expressionEvaluator = expressionEvaluator;
_programRepository = programRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="List"/> class.
/// </summary>
/// <param name="programRepository">Program Repository.</param>
/// <param name="teletype">Output teletype to use.</param>
/// <param name="runEnvironment">Run environment.</param>
public List(
IProgramRepository programRepository,
ITeletype teletype,
IRunEnvironment runEnvironment)
: base("LIST", TokenClass.Statement)
{
_programRepository = programRepository;
_teletype = teletype;
_runEnvironment = runEnvironment;
}
private void SetupSut()
{
_mockExpressionEvaluator = new Mock <IExpressionEvaluator>();
_runEnvironment = new RunEnvironment();
_variableRepository = new VariableRepository();
_toToken = new Token("TO", TokenClass.Statement, TokenType.To);
_colonToken = new Token(":", TokenClass.Seperator, TokenType.Colon);
_equalToken = new Token("=", TokenClass.Seperator, TokenType.Equal);
_stepToken = new Token("STEP", TokenClass.Statement, TokenType.Step);
_commaToken = new Token(",", TokenClass.Seperator, TokenType.Comma);
}
private void SetupSut()
{
_runEnvironment = new RunEnvironment();
_mockExpressionEvaluator = new Mock <IExpressionEvaluator>();
_variableRepository = new VariableRepository();
_variableReference = _variableRepository.GetOrCreateVariable("A", new short[] { });
_mockExpressionEvaluator.Setup(mre => mre.GetLeftValue()).Returns(_variableReference);
_mockExpressionEvaluator.Setup(mre => mre.GetExpression()).Returns(new Accumulator(3.0));
_sut = new Let(_runEnvironment, _mockExpressionEvaluator.Object);
}
/// <summary>
/// Initializes a new instance of the <see cref="New"/> class.
/// </summary>
/// <param name="runEnvironment">Run time environment.</param>
/// <param name="programRepository">Program Repository.</param>
/// <param name="variableRepository">Variable Repository.</param>
/// <param name="dataStatementReader">Data statement reader.</param>
public New(
IRunEnvironment runEnvironment,
IProgramRepository programRepository,
IVariableRepository variableRepository,
IDataStatementReader dataStatementReader)
: base("NEW", TokenClass.Statement)
{
_runEnvironment = runEnvironment;
_programRepository = programRepository;
_variableRepository = variableRepository;
_dataStatementReader = dataStatementReader;
}
private void SetupSut()
{
_mockTeletype = new MockTeletype();
// Use a real RunEnvironment
_runEnvironment = new RunEnvironment();
_mockListToken = new Mock <IToken>();
_mockListToken.Setup(mlt => mlt.Statement).Returns(TokenType.Unknown);
_mockListToken.Setup(mlt => mlt.TokenClass).Returns(TokenClass.Statement);
_mockListCmd = _mockListToken.As <IInterruptableCommand>();
_mockRunToken = new Mock <IToken>();
_mockRunToken.Setup(mrt => mrt.TokenClass).Returns(TokenClass.Statement);
_mockRunToken.Setup(mrt => mrt.Statement).Returns(TokenType.Unknown);
_mockRunCmd = _mockRunToken.As <ITokeniserCommand>();
_mockLetToken = new Mock <IToken>();
_mockLetToken.Setup(mlt => mlt.Statement).Returns(TokenType.Let);
_mockLetCmd = _mockLetToken.As <ICommand>();
_mockLetCmd.Setup(mlt => mlt.Execute())
.Callback(() => _runEnvironment.CurrentLine.NextToken());
_mockPrintToken = new Mock <IToken>();
_mockPrintToken.Setup(mpt => mpt.TokenClass).Returns(TokenClass.Statement);
_mockPrintCmd = _mockPrintToken.As <ICommand>();
_mockSystemToken = new Mock <IToken>();
_mockSystemToken.Setup(mst => mst.Statement).Returns(TokenType.System);
_mockColonToken = new Mock <IToken>();
_mockColonToken.Setup(mct => mct.Seperator).Returns(TokenType.Colon);
_mockNotStatement = new Mock <IToken>();
_mockNotStatement.Setup(mns => mns.TokenClass).Returns(TokenClass.Unknown);
_mockNotStatement.Setup(mns => mns.Seperator).Returns(TokenType.Unknown);
_mockNotStatement.Setup(mns => mns.Statement).Returns(TokenType.Unknown);
_mockTokensProvider = new Mock <ITokensProvider>();
_mockTokensProvider.Setup(mtp => mtp.Tokens).Returns(new List <IToken>
{
_mockLetToken.Object
});
_mockProgramRepository = new Mock <IProgramRepository>();
_sut = new Executor(
_mockTeletype,
_runEnvironment,
_mockProgramRepository.Object,
_mockTokensProvider.Object,
Mock.Of <ITokeniser>());
}
/// <summary>
/// Initializes a new instance of the <see cref="Input"/> class.
/// </summary>
/// <param name="runEnvironment">Run time environment.</param>
/// <param name="expressionEvaluator">Expression evaluator.</param>
/// <param name="variableRepository">Variable repository.</param>
/// <param name="teletype">Teletype to use.</param>
public Input(
IRunEnvironment runEnvironment,
IExpressionEvaluator expressionEvaluator,
IVariableRepository variableRepository,
ITeletype teletype)
: base("INPUT", TokenClass.Statement)
{
_runEnvironment = runEnvironment;
_expressionEvaluator = expressionEvaluator;
_variableRepository = variableRepository;
_teletype = teletype;
_readInputParser = new ReadInputParser(ReadLine);
}
private void SetupSut()
{
_runEnvironment = new RunEnvironment();
_mockProgramRepository = new Mock <IProgramRepository>();
_mockProgramRepository.Setup(mpr => mpr.GetLine(1000)).Returns(new ProgramLine(1000, new List <IToken> {
}));
_mockProgramRepository.Setup(mpr => mpr.GetLine(2000)).Returns(new ProgramLine(2000, new List <IToken> {
}));
_mockProgramRepository.Setup(mpr => mpr.GetLine(3000)).Returns(new ProgramLine(3000, new List <IToken> {
}));
_mockExpressionEvaluator = new Mock <IExpressionEvaluator>();
_sut = new On(_runEnvironment, _mockExpressionEvaluator.Object, _mockProgramRepository.Object);
}
/// <summary>
/// Initializes a new instance of the <see cref="Interpreter"/> class.
/// </summary>
/// <param name="teletypeWithPosition">Teletype to use for input output.</param>
/// <param name="tokeniser">Tokeniser.</param>
/// <param name="runEnvironment">Run time environment.</param>
/// <param name="programRepository">Program repository.</param>
/// <param name="executor">Executor class to run program lines.</param>
public Interpreter(
ITeletypeWithPosition teletypeWithPosition,
ITokeniser tokeniser,
IRunEnvironment runEnvironment,
IProgramRepository programRepository,
IExecutor executor)
{
_teletypeWithPosition = teletypeWithPosition;
_tokeniser = tokeniser;
_runEnvironment = runEnvironment;
_programRepository = programRepository;
_executor = executor;
}
/// <summary>
/// Initializes a new instance of the <see cref="Executor"/> class.
/// </summary>
/// <param name="teletype">Teletype to use for input output.</param>
/// <param name="runEnvironment">Run time environment.</param>
/// <param name="programRepository">Program repository.</param>
/// <param name="tokensProvider">Provider of tokens.</param>
/// <param name="tokeniser">Tokeniser to pass to ITokeniserCommands.</param>
public Executor(
ITeletype teletype,
IRunEnvironment runEnvironment,
IProgramRepository programRepository,
ITokensProvider tokensProvider,
ITokeniser tokeniser)
{
_runEnvironment = runEnvironment;
_programRepository = programRepository;
_tokeniser = tokeniser;
_letToken = tokensProvider.Tokens.Find(t => t.Statement == TokenType.Let);
teletype.CancelEventHandler += InterruptExecution;
}
