Tema: INTÉRPRETE ENSAMPOCO/3

Transcripción

1 Compiladores. Guía 11 1 Facultad: Ingeniería Escuela: Computación Asignatura: Compiladores Tema: INTÉRPRETE ENSAMPOCO/3 Contenido En esta práctica se desarrollará un intérprete de lenguaje ENSAMPOCO/3 para completar el desarrollo de un compilador. Objetivos Específicos Aplicar y definir los conceptos de intérprete de un lenguaje. Material y Equipo Guía de Laboratorio Nº 11. Computadora con DevC++ Introducción Teórica Intérpretes Los Guía intérpretes 3 son programas que simplemente ejecutan las instrucciones que encuentran en el texto fuente. En Guía muchos 4 casos coexisten en memoria el programa fuente y el programa intérprete. Nótese que en este caso todo se hace en tiempo de ejecución. Algunos fía de los lenguajes comúnmente interpretados son el BASIC, LOGO, PROLOG, SMALLTALK, APL, PHP y LISP. Funcionamiento de un intérprete Evidentemente la ejecución de un programa compilado será más rápida que la del mismo programa interpretado. Sin embargo los intérpretes son más interactivos y facilitan la puesta a punto de programas.

2 2 Compiladores. Guía 11 Algunos lenguajes de programación tan sólo pueden ser interpretados debido a sus características, por ejemplo algunos lenguajes funcionales y lenguajes orientados a objeto. En estos casos existen intérpretes con compiladores incrementales que pueden recompilar los módulos modificados en tiempo de ejecución. Los intérpretes se pueden clasificar desde el punto de vista de su estructura en varios tipos: intérpretes puros, intérpretes avanzados o normales, e intérpretes incrementales. Intérpretes puros Los intérpretes puros son los que analizan una sentencia y la ejecutan, y así sucesivamente todo el programa fuente. Fueron los intérpretes desarrollados en la primera generación de ordenadores, pues permitían la ejecución de largos programas con ordenadores de memoria muy reducida, ya que sólo debían contener en memoria el intérprete y la sentencia a analizar y ejecutar. El principal problema de este tipo de intérpretes es que si a mitad del programa fuente se producen errores, se debe de volver a comenzar el proceso. En la figura se representa el esquema general de un intérprete puro, donde se puede observar que el lenguaje fuente se traduce a una representación interna (texto o binaria) que puede ser almacenada en memoria o en disco. Esta representación interna tiene todas las instrucciones numeradas o colocadas consecutivamente en estructuras de tamaño fijo (por ejemplo un array o posiciones consecutivas de memoria, o un fichero binario de estructuras de tamaño fijo). Mientras se realiza este paso se puede construir la tabla de etiquetas, que es una tablas que contiene una estructura donde están todas las etiquetas y su posición en el programa fuente (las etiquetas se utilizan tanto en las instrucciones de salto como en las llamadas a procedimientos y funciones). Una vez que este proceso ha finalizado, comienza la ejecución por la primera instrucción del código, que se envía al evaluador de instrucciones, éste la ejecuta (recibiendo datos si es necesario o enviando un mensaje de error). El evaluador de instrucciones también determina la instrucción siguiente a ejecutar, en algunos casos previa consulta a la tabla de etiquetas. En el caso de que no haya saltos (GOTO) o llamadas a procedimientos o funciones se ejecuta la siguiente instrucción a la instrucción en curso.

3 Compiladores. Guía 11 3 El evaluador de instrucciones puede utilizar dos métodos de evaluación. El método clásico es la evaluación voraz o ansiosa, donde se evalúan las expresiones completamente. Otro método es la evaluación perezosa, evaluándose sólo la parte necesaria de la expresión (el resto no se evalúa). Esquema general de un intérprete puro Intérpretes avanzados Los intérpretes avanzados o normales incorporan un paso previo de análisis de todo el programa fuente. Generando posteriormente un lenguaje intermedio que es ejecutado por ellos mismos. De esta forma en caso de errores sintácticos no pasan de la fase de análisis. Un ejemplo de intérprete avanzado es el que utiliza el lenguaje Java [JAVAi]. Así un programa en lenguaje java (con la extensión.java) se compila y produce uno o varios ficheros con la extensión.class, estos ficheros están en un formato binario denominado bytecode independiente de plataforma, que se interpreta posteriormente. Esto permite que el bytecode se ejecute en cualquier sistema operativo que disponga de un intérprete de bytecode. Dado que la mayor parte de los navegadores de Internet llevan inmerso un intérprete de bytecode, esto ha permitido al lenguaje Java ser uno de los más utilizados en aplicaciones que usen Internet.

4 4 Compiladores. Guía 11 Esquema general de un intérprete avanzado Las aplicaciones de los intérpretes avanzados son: Emulación de arquitecturas de ordenadores. Método para facilitar la portabilidad de aplicaciones entre distintas arquitecturas de ordenadores. Fase de prueba de lenguajes y arquitecturas de máquinas abstractas, antes de construir los traductores a código objeto de una arquitectura determinada. Intérpretes incrementales Algunos lenguajes no se pueden compilar, debido a que entre sus características pueden manejar objetos o funciones que no son conocidos en tiempo de compilación, ya que son creados en ejecución. Para este tipo de lenguajes existen los intérpretes incrementales, que permiten compilar los módulos completamente definidos, y recompilar en tiempo de ejecución los nuevos módulos. Están a medio camino entre los intérpretes puros y los intérpretes avanzados o normales. Los intérpretes incrementales tienen gran interés en los lenguajes que permiten no definir los problemas completamente en tiempo de compilación. En estos casos se utilizan evaluadores parciales (partial evaluators) que toman como entrada el programa fuente junto con algunos datos (pero no todos), realizándose los cálculos que se pueden hacer con dicho subconjunto de datos, y produciendo una salida que contiene un residuo del programa fuente que se ha introducido.

5 Compiladores. Guía 11 5 Algunos fabricantes de software denominan a los intérpretes incrementales como compiladores incrementales, debido a que la palabra intérprete está desprestigiada, y prefieren acogerse a la parte del intérprete avanzado. Procedimiento Considerando la clase Interprete, desarrolle un proyecto en C++ que solicite el nombre del archivo en ENSAMPOCO/3 y a continuación Guía 3 ejecute el interprete del archivo. InterpreteEnsampoco.h Guía 4 #ifndef INTERPRETE_H #define INTERPRETE_H #include fía <stdio.h> #include <iostream> #include <string.h> #include <math.h> #include <stdlib.h> #define TAM_MAX_INS 20 using namespace std; struct pila { char valor; struct pila *sucesor; ; typedef struct pila ELEMENTO; typedef ELEMENTO *PUNTERO; class Interprete{ FILE *entrada; //Descriptor del fichero de entrada bool escodigo; int memoria[26]; PUNTERO cabezapila; char instruccion[tam_max_ins]; char parametro; void analizarinstruccion(); void interpretarinstruccion(); void interpretarinstrucciondecaracter(); void interpretarinstrucciondeflotante(); void interpretarinstrucciondeint(); void iabs(); void add(); void code(); void data(); void div(); void end();

6 6 Compiladores. Guía 11 void iexp(); void i2tof(); void itof(); void load(); void mod(); void mul(); void neg(); void output(); void input(); void pusha(); void pushc(); void isin(); void store(); void itan(); int pop(); void push(int valor); void error(int num); public: Interprete (char *unnombreficheroentrada); ~Interprete (void); ; Interprete::Interprete (char *unnombreficheroentrada){ int i; if ((entrada = fopen(unnombreficheroentrada,"r")) == NULL ) error(0); for(i= 0; i<26; i++) memoria[i] = 0;//inicialización a cero while (!feof(entrada)){ analizarinstruccion(); if (instruccion[0]!= '\0') interpretarinstruccion(); else{ cout<<"fin\n"; return; /**********************************************************/ Interprete::~Interprete (void){ fclose(entrada); /**********************************************************/ void Interprete::analizarInstruccion(){ int n; if ((instruccion[0] = fgetc(entrada))!= EOF){ n = 1; while (((instruccion[n] = fgetc(entrada))!= ' ') && (instruccion[n]!= '\n'))

7 Compiladores. Guía 11 7 n++; if (instruccion[n]!= '\n'){ while (((parametro = fgetc(entrada)) == ' ') && (parametro!= '\n')) ; instruccion[n] = '\0'; if (parametro!= '\n'){ while ((n = fgetc(entrada))!= '\n'); else{ instruccion[n] = '\0'; else instruccion[0]='\0'; void Interprete::interpretarInstruccion() { switch (instruccion[0]) { case 'C': interpretarinstrucciondecaracter(); case '.': if (strcmp (instruccion,".data") == 0) data(); else if (strcmp (instruccion,".code") == 0) code(); case 'E': if (strcmp (instruccion,"end") == 0) end(); case 'F': interpretarinstrucciondeflotante(); case 'I':if (strcmp(instruccion,"itof") == 0) itof(); else if (strcmp(instruccion,"i2tof") == 0) i2tof(); else interpretarinstrucciondeint(); default : error(1); return; void Interprete::interpretarInstruccionDeCaracter() { if(!escodigo) return; switch(instruccion[1]){ case 'I': if (strcmp(instruccion,"cinput") == 0) input();

8 8 Compiladores. Guía 11 case 'L': if (strcmp(instruccion,"cload") == 0) load(); case 'O': if (strcmp(instruccion,"coutput") == 0) output(); case 'P': if (strcmp(instruccion,"cpusha") == 0) pusha(); case 'S': if (strcmp(instruccion,"cstore") == 0) store(); default: error(1); void Interprete::interpretarInstruccionDeFlotante(){ if(!escodigo) return; switch(instruccion[1]){ case 'A': if(strcmp(instruccion,"fabs")==0) iabs(); else if (strcmp(instruccion,"fadd") == 0) add(); case 'D': if (strcmp(instruccion,"fdiv") == 0) div(); case 'E': if (strcmp(instruccion,"fexp") == 0) iexp(); case 'I': if (strcmp(instruccion,"finput") == 0) input(); case 'L': if (strcmp(instruccion,"fload") == 0) load();

9 Compiladores. Guía 11 9 case 'M': if (strcmp(instruccion,"fmul") == 0) mul(); else if (strcmp(instruccion,"fmod") == 0) mod(); case 'N': if (strcmp(instruccion,"fneg") == 0) neg(); case 'O': if (strcmp(instruccion,"foutput") == 0) output(); case 'P': if (strcmp(instruccion,"fpusha") == 0) pusha(); case 'S': if (strcmp(instruccion,"fsin") == 0) isin(); else if (strcmp(instruccion,"fstore") == 0) store(); case 'T': if (strcmp(instruccion,"ftan") == 0) itan(); default: error(1); void Interprete::interpretarInstruccionDeInt() { if(!escodigo) return; switch(instruccion[1]){ case 'A': if (strcmp(instruccion,"iabs") == 0) iabs(); else if(strcmp(instruccion,"iadd")==0) add(); case 'D': if (strcmp(instruccion,"idiv") == 0) div(); case 'E': if (strcmp(instruccion,"iexp") == 0) iexp();

10 10 Compiladores. Guía 11 case 'I': if (strcmp(instruccion,"iinput") == 0) input(); case 'L': if (strcmp(instruccion,"iload") == 0) load(); case 'M': if (strcmp(instruccion,"imul") == 0) mul(); else if (strcmp(instruccion,"imod") == 0) mod(); case 'N': if (strcmp(instruccion,"ineg") == 0) neg(); case 'O': if (strcmp(instruccion,"ioutput") == 0) output(); case 'P':if (strcmp(instruccion,"ipushc") == 0) pushc(); else if (strcmp(instruccion,"ipusha") == 0) pusha(); case 'S': if (strcmp(instruccion,"isin")==0) isin(); else if (strcmp(instruccion,"istore") == 0) store(); case 'T': if(strcmp(instruccion,"itan")==0) itan(); default: error(1); //**** INSTRUCCIONES DE ENSAMPOCO ***** void Interprete::iabs(){ push(abs(pop())); void Interprete::add() {

11 Compiladores. Guía PUNTERO p; p = cabezapila; cabezapila = cabezapila->sucesor; cabezapila->valor = cabezapila->valor+p->valor; free((puntero)p); void Interprete::code() { escodigo=true; void Interprete::data(){ escodigo=false; void Interprete::div() { PUNTERO p; p = cabezapila; cabezapila = cabezapila->sucesor; cabezapila->valor = (int) (cabezapila->valor / p->valor); free((puntero)p); void Interprete::end() { return; void Interprete::iexp() { double a = pop(); double b = pop(); //System.out.println(b+" ^ "+a+"= "+ Math.pow(b, a)); push((int)pow(b, a)); void Interprete::i2tof() { //de momento nada la conversion de entero a float es //automatica en c++ void Interprete::input() { int valor; cout<<"entrada "<<parametro<<" > "; cin>>valor; memoria[parametro - 'a'] = valor; void Interprete::itof(){ //de momento nada la conversion de entero a float es //automatica en c++ void Interprete::load() { cabezapila->valor = memoria[cabezapila->valor-'a']; void Interprete::mod() {

12 12 Compiladores. Guía 11 PUNTERO p; p = cabezapila; cabezapila = cabezapila->sucesor; cabezapila->valor = (( (int)cabezapila->valor) % ( (int) p->valor) ); free((puntero)p); void Interprete::mul() { PUNTERO p; p = cabezapila; cabezapila = cabezapila->sucesor; cabezapila->valor = cabezapila->valor*p->valor; free((puntero)p); void Interprete::neg() { cabezapila->valor = -cabezapila->valor; void Interprete::output() { cout<<"salida "<<parametro<<" > "<< memoria[parametro- 'a']<<endl; system("pause"); void Interprete::pusha() { PUNTERO p; p = (PUNTERO) malloc (sizeof(elemento)); p->valor = parametro; p->sucesor = cabezapila; cabezapila = p; void Interprete::pushc() { PUNTERO p; p = (PUNTERO) malloc (sizeof(elemento)); p->valor = parametro-'0'; p->sucesor = cabezapila; cabezapila = p; void Interprete::isin(){ push((int)sin(pop())); void Interprete::store() { PUNTERO p,q; p = cabezapila; q = cabezapila->sucesor; if (q->sucesor!=null) cabezapila = q->sucesor; else cabezapila=null; memoria[(q->valor)-'a'] = p->valor; free((puntero)p);

13 Compiladores. Guía free((puntero)q); void Interprete::itan(){ push((int)tan(pop())); //********* FIN DE LAS INSTRUCCIONES DE ENSAMPOCO ******* int Interprete::pop() { int valor = cabezapila->valor; cabezapila = cabezapila->sucesor; return valor; void Interprete::push(int valor) { PUNTERO nuevo;// = new PUNTERO(); nuevo->valor = valor; nuevo->sucesor = cabezapila; cabezapila = nuevo; void Interprete::error(int num){ // Manejo de errores cout<<"error "<<num; switch (num){ case 0: cout<<": No encuentra el fichero fuente"<<endl; case 1: cout<<": Instrucción desconocida"<<endl; case 2: cout<<": PUSHA sin variable"<<endl; case 3: cout<<": PUSHC sin constante"<<endl; case 4: cout<<": INPUT sin variable"<<endl; case 5: cout<<": OUTPUT sin vaariable"<<endl; default: cout<<": No documentado"<<endl; #endif Análisis de resultados Teniendo en cuenta el siguiente código en lenguaje ensampoco/3 ejecute el intérprete implementado anteriormente y describa su funcionamiento. Prueba.poc.DATA INT a INT b FLOAT c FLOAT d

14 14 Compiladores. Guía 11.CODE IINPUT a IINPUT b FPUSHA c IPUSHA a ILOAD IPUSHA b ILOAD IADD ITOF FSTORE FPUSHA d IPUSHA a ILOAD IPUSHA b ILOAD INEG IADD ITOF FSTORE FOUTPUT c FOUTPUT d END Responda las siguientes cuestiones: Describa el algoritmo de la clase intérprete. Clasifique y distinga, qué tipo de intérprete es el implementado para ENSAMPOCO/3? Explique, en el caso de ENSAMPOCO/0 que no acepta tipos, cuáles cambios consideraría usted que deberían ser hechos a este intérprete, para interpretar ENSAMPOCO/0? Investigación complementaria Investigue que es un traductor, documente las partes que lo componen y la actividad principal. Además haga un cuadro comparativo entre compiladores, traductores e intérpretes. Bibliografía Cueva, J. (1998). Conceptos básicos de procesadores de lenguaje. Universidad de Oviedo, España.

15 Compiladores. Guía Guía 11: Intérprete de Ensampoco/3 Tema: Presentación del programa Alumno: Alumno: Docente: Docente: Hoja de cotejo: Docente: Máquina No: Máquina No: Máquina No: GL: GL: Fecha: a GL: 11 1 EVALUACION % Nota CONOCIMIENTO Del 20 al 30% Conocimie nto deficient e de los fundament os teóricos Conocimiento y explicación incompleta de los fundamentos teóricos Conocimiento completo y explicación clara de los fundamentos teóricos APLICACIÓN DEL CONOCIMIENTO Del 40% al 60% ACTITUD Del 15% al 30% No tiene actitud proactiva. Actitud propositiva y con propuestas no aplicables al contenido de la guía. Tiene actitud proactiva y sus propuestas son concretas. TOTAL 100%