Creando tu propio Lenguaje de Programación

A continuación encontrarás traducido al Castellano el artículo escrito por Pail Lefebvre y publicado originalmente en el Blog oficial de Xojo.

Computerphile es uno de mis canales favoritos de YouTube. Está repleto de “vídeos sobre ordenadores y otros temas relacionados”, generalmente temas muy nerd. Uno de sus vídeos más recientes es “Creando tu Propio Lenguaje de Programación“, y de hecho es uno realmente interesante de ver. En una duración de unos 20 minutos Dr. Laurie Tratt (del King’s College London) crea un lenguaje de programación realmente simple en tan solo unas cuantas líneas de código.

Dr. Tratt crea su lenguaje sin nombre utilizando Python y pensé que podría resultar divertido portarlo a Xojo. Antes de que echemos un vistazo a la versión de Xojo, este es un breve resumen del lenguaje, el cual es todo lo escueto que podría ser.

En primer lugar, y para simplificar las cosas, utiliza la notación RPN para las expresiones (Reverse Polish Notation, Notación Polaca Inversa). Si no estás familiarizado con ello, se trata de una forma diferente de escribir una expresión donde el operador se sitúa tras los operadores. Por ejemplo, utilizando la notación de infijo (Infix Notation) escribirías una expresión para sumar dos números de la siguiente forma:

2 + 4

Con RPN, sería así:

2 4 +

Parece un poco rara, pero es mucho más fácil escribir código de esta forma, especialmente porque elimina la necesidad de utilizar paréntesis para determinar el orden de las operaciones.

La sintaxis para este lenguaje simple sólo soporta unas cuantas cosas:

Valores literales Enteros
Operadores matemáticos +, *, –
Asignación variable
Operación de comparación >=
Bucle While…End

Por último, este pequeño lenguaje también incorpora comprobación de errores y sólo muestra la salida de los contenidos de las variables.

Con todo lo anterior, puede ejecutar el programa mostrado en el vídeo, el cual calcula el factorial de un número:

n = 5
r = 1
while n 1 >=
  r = r n *
  n = n 1 -
end

He denominado a la versión de Xojo PLX y aquí muestra el resultado de ejecutar el anterior programa para calcular el factorial de 5:

¡La notación RPN hace que el código resulte ciertamente raro! Actualmente son pocos los lenguajes que utilizan RPN por este motivo, aunque fue utilizado por algunas antiguas calculadoras de HP y en el lenguaje de programación Forth.

El porte a Xojo replica prácticamente la versión de Python dado que los dos lenguajes no son tan diferentes. Sin embargo, el código hace un uso elevado del comando Split para realizar un parseado rudimentario y Python no incluye una versión de split en la que se devuelva el número de divisiones o bien una versión de split que descarte ítems vacíos. En el módulo Util encontrarás versiones de Xojo para estas extensiones de método de una String.

También me he tomado la libertad de utilizar nombres de variables más largos en el código de Xojo. He visto que los académicos tienden a utilizar nombres cortos para las cosas, quizá debido a su base en matemáticas o quizá porque no sean hábiles a la hora de escribir. En cualquier caso, el uso de nombres cortos hace que el código sea más difícil de leer, en mi opinión.

La clase Evaluator contiene el “lenguaje” y cuenta con dos métodos: Evaluate y EvaluateExpression. También hay una propiedad, Variables, que contiene la lista de variables y sus valores.

El método Evaluate parsea las cosas y llama a EvaluateExpression cuando es necesario:

Public Function Evaluate(source As String) As JSONItem
  Variables = New JSONItem
  source = source.ReplaceLineEndings(EndOfLine)
  Var lines() As String = source.Split(EndOfLine, True)
  Var programCounter As Integer = 0
  
  While programCounter < lines.Count
    Var line As String = lines(programCounter).Trim
    Var parts() As String = line.Split(" ", 1)
    Select Case parts(0)
    Case "while"
      parts = line.Split(" ", 1)
      If EvaluateExpression(parts(1)) = 1 Then
        // The conditon was true, so process the code in the loop.
        programCounter = programCounter + 1
      Else
        // The condition was false, so search ahead for the "end", skipping the loop.
        parts = lines(programCounter).Split(" ", 1)
        While parts(0) <> "end"
          programCounter = programCounter + 1
          parts = lines(programCounter).Split(" ", 1)
        Wend
        programCounter = programCounter + 1
      End If
    Case "end"
      // Search back for the while to evaluate its expression again.
      parts = lines(programCounter).Split(" ", 1)
      While parts(0) <> "while"
        programCounter = programCounter - 1
        parts = lines(programCounter).Split(" ", 1)
      Wend
    Else
      // Variable assignment and expression.
      parts = line.Split(" ", 2)
      
      Var name As String = parts(0)
      Var expr As String = parts(2)
      
      Variables.Value(name) = EvaluateExpression(expr)
      
      programCounter = programCounter + 1
    End Select
  Wend
  
  Return Variables
End Function

El método EvaluateExpression gestiona los operadores y los operandos en las expresiones:

Public Function EvaluateExpression(expr As String) As Integer
  Var tokens() As String = expr.Split
  Var stack() As Integer
  
  For Each token As String In tokens
    If IsNumeric(token) Then
      // Push the literal value on the stack.
      stack.Add(Integer.FromString(token))
    ElseIf Variables.HasKey(token) Then
      // This is a variable so push its value on the stack.
      stack.Add(Variables.Value(token).IntegerValue)
    Else
      // Process various operators using what is on the stack.
      Var rhs As Integer = stack.Pop
      Var lhs As Integer = stack.Pop
      
      If token = "+" Then
        stack.Add(lhs + rhs)
      ElseIf token = "*" Then
        stack.Add(lhs * rhs)
      ElseIf token = "-" Then
        stack.Add(lhs - rhs)
      ElseIf token = ">=" Then
        If lhs >= rhs Then
          stack.Add(1)
        Else
          stack.Add(0)
        End If
      End If
    End If
  Next
  
  Return stack(0)
End Function

Te animo a que reproduzcas el vídeo para contar con las explicaciones completas del Dr. Tratt. Este te guía sobre el proceso de crear este lenguaje por partes, mientras que aquí sólo te muestro la versión final.

Descarga PLX.

Juega con el código fuente, quizá ampliándolo con tus propios comandos.

Related Posts / Entradas Relacionadas