Ejemplo clase 20 Abril FLP

#lang eopl

(define lexica
'((white-sp
   (whitespace) skip)
  (comment
   ("%" (arbno (not #\newline))) skip)
  (number
   (digit (arbno digit)) number)
  (texto
   (letter (arbno (or letter digit))) string)
  (number
   ("-" digit (arbno digit)) number)))


(define gramatica
  '(
    (programa (expresion) un-programa)
    (expresion (number) numero-lit)
    (expresion ("\"" texto "\"") texto-lit)
    (expresion (primitiva "[" (separated-list expresion ";") "]") primitiva-exp)
    (expresion (texto) identificador)
    (primitiva ("+") primitiva-sum)
    (primitiva ("-") primitiva-resta)
    (primitiva ("*") primitiva-mult)
    (primitiva ("/") primitiva-div)
    (primitiva ("concat") primitiva-concat)
    (primitiva ("length") primitiva-lenght)
    ;;Viene lo nuevo
    (expresion ("Si"  expresion  "entonces" expresion "sino" expresion "fin") cond-exp)
    ;;Variables locales
    (expresion ("declarar" (separated-list texto "=" expresion ";") "haga" expresion "fin") variableLocal-exp)
    ;;Procedimientosx
    (expresion ("procedimiento" "[" (separated-list texto ";") "]" "haga" expresion "fin") procedimiento-exp)
    ;evaluar procedimiento
    (expresion ("evaluar" texto "enviando" "[" (separated-list expresion ";") "]" "fin") evaluacion-exp)
  )
  )


;Construidos automáticamente:

(sllgen:make-define-datatypes lexica gramatica)

(define show-the-datatypes
  (lambda () (sllgen:list-define-datatypes lexica gramatica)))

;*******************************************************************************************
;Parser, Scanner, Interfaz

;El FrontEnd (Análisis léxico (scanner) y sintáctico (parser) integrados)

(define scan&parse
  (sllgen:make-string-parser lexica gramatica))

;El Analizador Léxico (Scanner)

(define just-scan
  (sllgen:make-string-scanner lexica gramatica))

;El Interpretador (FrontEnd + Evaluación + señal para lectura )

(define interpretador
  (sllgen:make-rep-loop "--> "
    (lambda (pgm) (evaluar-programa  pgm))
    (sllgen:make-stream-parser
      lexica
      gramatica)))

(define evaluar-programa
  (lambda (pgm)
    (cases programa pgm
      (un-programa (exp) (evaluar-expresion exp (ambienteInicial))
    ))))

(define evaluar-expresion
  (lambda (expr amb)
    (cases expresion expr
      (numero-lit (numerito) numerito)
      (texto-lit (textico) textico)
      (primitiva-exp (prim lexp) "primitiva")
      (identificador (id) (evaluar-expresion (buscarVariable (string->symbol id) amb) amb))
      (else "jaja")
    )))


;Definición de ambiente
;<ambiente>: (vacio) '()
;           (extendido) (lista-simbolos) (lista-expresiones) ;<ambiente>
(define-datatype ambiente ambiente?
  (ambiente-vacio)
  (ambiente-extendido
   (ids (list-of symbol?))
   (valores (list-of expresion?))
   (amb ambiente?)
   )
  )

;;Definir un ambiente inicial
;Defina un ambiente inicial con los simbolos ("a" "b" "c") con valores ((numero-lit 1) (numero-lit 2) (numero-lit 3)), modifique evaluar-expresion para que se acepte

(define ambienteInicial
  (lambda ()
    (ambiente-extendido
     '(a b c)
     (list (numero-lit 1) (numero-lit 2) (numero-lit 3))
     (ambiente-vacio))))

(define buscarVariable
  (lambda (variable amb)
    (cases ambiente amb
      (ambiente-vacio () (eopl:error "No encontré la variable"))
      (ambiente-extendido
       (lids lvalores ambanterior)
       (let
         ( (pos (buscarSimbolo variable lids 1)))
         (cond
           [ (not (zero? pos)) (buscarValor pos lvalores)]
           [else (buscarVariable variable ambanterior)]
           )
         )
       )
      )
    )
  )





(define buscarSimbolo
  (lambda (sim listS acc)
    (cond
      [(null? listS) 0]
      [(eqv? sim (car listS)) acc]
      [else (buscarSimbolo sim (cdr listS) (+ 1 acc))]
      )
    )
  )

(define buscarValor
  (lambda (pos lValores)
    (cond
      [(= 1 pos) (car lValores)]
      [else (buscarValor (- pos 1) (cdr lValores))]
      )
    )
  )

(interpretador)