PDF de programación - Intérpretes y Diseño de Lenguajes de Programación

Intérpretes y Diseño de
Lenguajes de Programación



- 1 -

Jose Emilio Labra Gayo
Juan Manuel Cueva Lovelle
Raúl Izquierdo Castanedo
Aquilino Adolfo Juan Fuente
Mª Cándida Luengo Díez
Francisco Ortín Soler

Fecha: Abril 2004





Tabla de Contenidos

1. Intérpretes ________________________________________________________________________ 3
1.1. Definición_____________________________________________________________________ 3
1.2. Estructura de un intérprete ______________________________________________________ 3
1.3. Ventajas de la utilización de intérpretes ____________________________________________ 5
1.4. Aplicaciones de los sistemas basados en intérpretes___________________________________ 5
1.5. Tipos de intérpretes ____________________________________________________________ 6
1.6. Ejemplo de intérprete de código intermedio________________________________________ 12
1.7. Ejemplo de intérprete de lenguaje recursivo _______________________________________ 19
2. Diseño de Lenguajes de Programación ________________________________________________ 24
2.1. Aspectos lingüísticos ___________________________________________________________ 24
2.2. Principios de diseño ___________________________________________________________ 24
2.3. Técnicas de Especificación semántica _____________________________________________ 25
2.4. Familias de Lenguajes _________________________________________________________ 27
2.5. Lenguajes de Dominio Específico ________________________________________________ 38
2.6. Máquinas abstractas ___________________________________________________________ 39
Ejercicios Propuestos ________________________________________________________________ 41
Referencias ________________________________________________________________________ 42


- 2 -

1. Intérpretes

Definición

1.1. Definición
Un intérprete es un programa que analiza y ejecuta simultáneamente un programa escrito en un

En la Figura 1 se presenta el esquema general de un intérprete visto como una caja negra.
Cualquier intérprete tiene dos entradas: un programa P escrito en un lenguaje fuente LF (en lo sucesivo,
se denotará P/LF) junto con los datos de entrada; a partir de dichas entradas, mediante un proceso de
interpretación va produciendo unos resultados.

lenguaje fuente.



P/LF



Datos

Intérprete

de LF


Figura 1: Esquema general de un intérprete

Resultados


Los compiladores, a diferencia de los intérpretes, transforman el programa a un programa
equivalente en un código objeto (fase de compilación), y en un segundo paso generan los resultados a
partir de los datos de entrada (fase de ejecución).



P/LF



Compilador

de LF

Datos

P/OBJ

Compilación

Ejecución

Resultados



Figura 2: Esquema general de un compilador

1.2. Estructura de un intérprete
A la hora de construir un intérprete es conveniente utilizar una Representación Interna (RI) del
lenguaje fuente a analizar. De esta forma, la organización interna de la mayoría de los intérpretes se
descompone en los módulos:

Traductor a Representación Interna: Toma como entrada el código del programa P en
Lenguaje Fuente, lo analiza y lo transforma a la representación interna correspondiente a dicho programa
P.

Representación Interna (P/RI): La representación interna debe ser consistente con el programa
original. Entre los tipos de representación interna, los árboles sintácticos son los más utilizados y, si las
características del lenguaje lo permiten, pueden utilizarse estructuras de pila para una mayor eficiencia.

Tabla de símbolos: Durante el proceso de traducción, es conveniente ir creando una tabla con
información relativa a los símbolos que aparecen. La información a almacenar en dicha tabla de símbolos
depende de la complejidad del lenguaje fuente. Se pueden almacenar etiquetas para instrucciones de
salto, información sobre identificadores (nombre, tipo, línea en la que aparecen, etc.) o cualquier otro tipo
de información que se necesite en la etapa de evaluación.

Evaluador de Representación Interna: A partir de la Representación Interna anterior y de los
datos de entrada, se llevan a cabo las acciones indicadas para obtener los resultados. Durante el proceso
de evaluación es necesario contemplar la aparición de errores.

- 3 -

Tratamiento de errores: Durante el proceso de evaluación pueden aparecer diversos errores

como desbordamiento de la pila, divisiones por cero, etc. que el intérprete debe contemplar.

Intérprete de LF

Estructura de un intérprete

P/LF

Datos

Traductor
LF a RI

P/RI

Tabla

Símbolos

Evaluador

RI

Tratamiento
de Errores

Resultados

Errores



Figura 3: Organización interna de un intérprete

Dependiendo de la complejidad del código a analizar, el intérprete puede contener módulos
similares a los de un compilador tradicional: Análisis léxico, Sintáctico y Semántico. Durante la evaluación,
el intérprete interactúa con los recursos del sistema como la memoria, discos, etc. Muchos sistemas
interpretados liberan al programador del manejo explícito de memoria mediante técnicas de recolección
de basura.

A la hora de evaluar la representación interna, existen dos métodos fundamentales: la

interpretación iterativa y la interpretación recursiva.

1.2.1. Interpretación Iterativa
La interpretación iterativa es apropiada para lenguajes sencillos, donde se analiza y ejecuta cada
expresión de forma directa, como podrían ser los códigos de máquinas abstractas o lenguajes de
sentencias simples. La interpretación consiste en un ciclo básico de búsqueda, análisis y ejecución de
instrucciones.

El esquema sería:

Inicializar
REPETIR
Buscar siguiente Instrucción i
SI encontrada ENTONCES



Analizar i
Ejecutar i


HASTA (que no haya más instrucciones)

Figura 4: Interpretación iterativa

Cada instrucción se busca en el almacenamiento (memoria o disco) o, en algunos casos, es
introducida directamente por el usuario. Luego la instrucción es analizada en sus componentes y
ejecutada. Normalmente, el lenguaje fuente contiene varios tipos de instrucciones, de forma que la
ejecución se descompone en varios casos, uno por cada tipo de instrucción. En la página 42, se
construye un intérprete iterativo de un sencillo lenguaje intermedio.

1.2.2. Interpretación Recursiva
Comúnmente, el diseño de nuevos lenguajes de programación se realiza en dos fases:
Una primera fase de especificación semántica mediante la construcción de un intérprete
prototipo que actúa como una especificación ejecutable y una segunda fase de implementación del
compilador de dicho lenguaje.

Para la construcción de prototipos suele utilizarse un modelo de interpretación recursiva donde
las sentencias pueden estar compuestas de otras sentencias y la ejecución de una sentencia puede
lanzar la ejecución de otras sentencias de forma recursiva.

Los intérpretes recursivos no son apropiados para aplicaciones prácticas debido a su ineficiencia

y se utilizan únicamente como prototipo ejecutable del lenguaje.

El problema de especificar un lenguaje mediante un intérprete prototipo es decidir en qué
lenguaje se implementa dicho intérprete. Dicho lenguaje debe ser suficientemente expresivo y no ambigüo
para definir claramente cómo funcionan las diferentes construcciones. En muchos casos se opta por
utilizar lenguajes ya implementados pero que carecen de una especificación semántica clara. La
tendencia actual es investigar técnicas de especificación semántica formal que permitan generar
automáticamente este tipo de intérpretes [Espinosa94], [Liang96], [Steele94].

- 4 -

Ventajas de la utilización de intérpretes

1.3. Ventajas de la utilización de intérpretes
En general, la utilización de compiladores permite construir programas más eficientes que los
correspondientes interpretados. Esto es debido a que durante la ejecución de código compilado no es
necesario realizar complejos análisis (ya se hicieron en tiempo de compilación), además, un buen
compilador es capaz de detectar errores y optimizar el código generado.

Los intérpretes, por definición, realizan la fase de análisis y ejecución a la vez, lo cual imposibilita
tales optimizaciones. Por esta razón, los sistemas interpretados suelen ser menos eficientes que los
compilados. No obstante, los nuevos avances informáticos aumentan la velocidad de procesamiento y
capacidad de memoria de los ordenadores. Actualmente, la eficiencia es un problema menos grave y
muchas veces se prefieren sistemas que permitan un desarrollo rápido de aplicaciones que cumplan
fielmente la tarea encomendada.

A continuación se enumeran una serie de ventajas de los sistemas interpretados:
Los intérpretes, en general, son más sencillos de implementar. Lo cual facilita el estudio de la
corrección del intérprete y proporciona nuevas líneas de investigación como la generación automática de
intérpretes a partir de las especificaciones semánticas del lenguaje.

Proporcionan una mayor flexibilidad que permite modificar y ampliar características del lenguaje
fuente. Muchos lenguajes como Lisp, APL, Prolog, etc. surgieron en primer lugar como sistemas
interpretados y posteriormente surgieron compiladores.

No es necesario contener en memoria todo el código fuente. Esto permite su utilización en
sistemas de poca memoria o en entornos de red, en los que se puede obtener el código fuente a medida
que se necesita [Plezbert 97].

Faci