Escribiendo un intérprete en .NET (Parte 1)

Hace un poco más de una semana, tuve la oportunidad de dar una charla sobre compiladores e intérpretes en .NET, en el Code Camp Buenos Aires http://www.codecamp.com.ar

Escribí varios intérpretes en .NET (AjSharp, AjTalk, AjLisp….) y sigo con ese desarrollo. Pero ahore, me gustaría ir explorando los pasos que sigo para escribir un simple intérprete, sin usar herramientas de construcción de gramáticas.

Primero, uso Driven Development. Para cada cosa que agrego en código, escribo el test, lo ejecuto en rojo, cambio el código para que quede en verde, y luego refactor. Pueden bajar el código de este primer post desde InterpreterStep01.zip). La solución es:

El punto de partida es una expression.

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


Escribí una interfaz, pero podría haber escrito una primera clase concreta, y entonces, extraer la interfaz luego de tener algo andando. En este intérprete simple, una expresión es algo a ser evaludado, como



3
”foo”
3+5
fun(a)



La primera clase concreta es ConstantExpression: new ConstantExpression(3) será evaludado a 3. Un diagrama de clase:





La implementación ConstantExpression:



    public class ConstantExpression : IExpression
    {
        private object value;
        public ConstantExpression(object value)
        {
            this.value = value;
        }
        public object Evaluate()
        {
            return this.value;
        }
    }


Tests simples:



    [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());
        }
    }


Los tests están en verde:





Buen code coverage:





Bien, es un ejemplo muy simple. Pero es un punto de partida. Próximos pasos: agregar el manejo de variables, su evaluación. Y luego, agregaré comandos, la asignaciónde valor a una variable. Podría escribir funciones, analizador léxico, parser, y más, todo usando TDD.



Nos leemos!



Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

This entry was posted in 11699, 1389, 8870. Bookmark the permalink.

Leave a Reply

Your email address will not be published. Required fields are marked *


*

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>