Writing an interpreter in .NET (Part 1)

I’m preparing a talk about writing interpreters and compilers in .NET, for Code Camp Buenos Aires http://www.codecamp.com.ar

I wrote many simple interpreters (AjSharp, AjTalk, AjLisp….) and I’m continuing with that work. But now, I would like to write the usual steps I follow for a simple interpreter.

First, I use Test Driven Development. For each artifact I add to the code, I write a test, make it run in read, change the code to run the test in green, and then refactor. (the code for this post can be downloaded from InterpreterStep01.zip). The solution for this post:

In this first installment of a post series, the initial point is the concept of an expression.

namespace Interpreter
{
    public interface IExpression
    {
        object Evaluate();
    }
}

I wrote an interface, but I could write a concrete class, and then, extract the interface. In this simple interpreter, an expression is something to be evaluated, like
3

    
”foo” 

3+5 
fun(a)
The first concrete class is ConstantExpression: new ConstantExpression(3) will be evaluated to 3. A class diagram:
 
ConstantExpression implementation:
    public class ConstantExpression : IExpression
    {
        private object value;
        public ConstantExpression(object value)
        {
            this.value = value;
        }
        public object Evaluate()
        {
            return this.value;
        }
    }

Simple tests:
    [TestClass]
    public class ExpressionTests
    {
        [TestMethod]
        public void EvaluateIntegerConstantExpression()
        {
            IExpression expression = new ConstantExpression(1);
            Assert.AreEqual(1, expression.Evaluate());
        }
        [TestMethod]
        public void EvaluateStringConstantExpression()
        {
            IExpression expression = new ConstantExpression("foo");
            Assert.AreEqual("foo", expression.Evaluate());
        }
    }

The test are in green:
 
Good code coverage:
 
Ok, it’s a very simple example. Next steps: add variables, its evaluation. In a third steps, I will add commands, and the set of a variable. I should write functions, lexer, parser, and more, all using TDD.
Keep tuned!
Angel “Java” Lopez

  
http://www.ajlopez.com 
http://twitter.com/ajlopez