PROCESADORES DEL LENGUAJES Septiembre 2017

Transcripción

1 PROCESADORES DEL LENGUAJES Septiembre 2017 NOMBRE: GRUPO: LENGUAJE DE PROGRAMACIÓN MP Un programa MP consta de un conjunto de interfaces para declarar procedimientos y un bloque para definir variables y llamadas a procedimientos. Los tipos predefinidos del lenguaje son enteros (int) y reales (real). Las expresiones aritméticas admitidas por el lenguaje se construyen desde números (p.e. 1.0, 1) y operaciones de suma (+), resta (-), multiplicación (*) y división (/). Las llamadas a procedimiento pueden ir o no precedidas de una interfaz. A continuación mostramos un ejemplo de programa MP: INTERFACE m1 //Declaración de interfaz p(r:int) p(r:real) g(i:int,j:real) INTERFACE m2 //Declaración de interfaz p(r:real) g(i:real,j:int) h() { a,b,c:int //Declaración de variables x,y,z:real h() //Llamadas a procedimientos m1.p(x-1.0) m2.h() m1.g(b,y+1) SE PIDE: Analizadores léxico y sintáctico para el lenguaje de programación MP. (3 puntos) Descripciones a entregar: [IMPLEMENTACIÓN] Parser Antlr para el lenguaje de programación MP. (2 puntos) class AnasintMP extends Parser programa : interfaces bloque interfaces : (interfaz)+ interfaz : INTERFACE IDENT (procedimiento)+ procedimiento : IDENT PA parametros PC PUNTOYCOMA parametros : (parametro COMA)=>parametro (COMA parametro)+ parametro parametro : IDENT DOSPUNTOS (ENTERO REAL) bloque : LLAVEABIERTA variables (lista_instrs)? LLAVECERRADA variables : (vars vars)=> vars variables vars

2 vars : IDENT (COMA IDENT)* DOSPUNTOS (ENTERO^ REAL^) PUNTOYCOMA lista_instrs : instruccion (lista_instrs)? instruccion : (IDENT PUNTO)=> IDENT PUNTO IDENT PA (lista_exprs)? PC PUNTOYCOMA IDENT PA (lista_exprs)? PC PUNTOYCOMA lista_exprs : expr (COMA expr)* expr : (expr1 (MAS MENOS POR DIV))=> expr1 (MAS MENOS POR DIV) expr expr1 expr1 : IDENT NENTERO NREAL [IMPLEMENTACIÓN] Lexer Antlr para el lenguaje de de programación MP (1 punto) class AnalexMP extends Lexer options{ importvocab = AnasintMP k=2 tokens{ INTERFACE = "INTERFACE" ENTERO = "int" REAL = "real" protected DIGITO: '0'..'9' protected LETRA: ('a'..'z' 'A'..'Z' '_') BT: (' ' '\t'){$settype(token.skip) SL: "\r\n" {newline() $settype(token.skip) COMENTARIO : "//" (options {greedy=false:.)* "\r\n" {$settype(token.skip) PUNTOYCOMA: '' PUNTO: '.' COMA: ',' PA: '(' PC: ')' DOSPUNTOS: ':' LLAVEABIERTA: '{' LLAVECERRADA: '' MAS: '+' MENOS: '-' POR: '*' DIV: '/' IDENT: LETRA(LETRA DIGITO)* NUM: ((DIGITO)+ PUNTO)=>(DIGITO)+ PUNTO (DIGITO)+ {$settype(nentero) (DIGITO)+ {$settype(nreal)

3 PROCESADORES DEL LENGUAJES Septiembre 2017 NOMBRE: GRUPO: LENGUAJE DE PROGRAMACIÓN MP Un programa MP consta de un conjunto de interfaces para declarar procedimientos y un bloque para definir variables y llamadas a procedimientos. Los tipos predefinidos del lenguaje son enteros (int) y reales (real). Las expresiones aritméticas admitidas por el lenguaje se construyen desde números (p.e. 1.0, 1) y operaciones de suma (+), resta (-), multiplicación (*) y división (/). En las operaciones aritméticas se admite operar mezclando enteros y reales siendo el resultado real. Las variables usadas y no declaradas se suponen que tienen un tipo indefinido. Toda expresión con una parte indefinida es de tipo indefinido. Las llamadas a procedimiento pueden ir o no precedidas de una interfaz. SE PIDE: Analizador semántico de programas MP que detecte los siguientes errores en llamadas a procedimientos: (Error 1) Interfaz inexistente. (Error 2) Procedimiento no declarado en una determinada interfaz. (Error 3) Procedimiento no declarado en ninguna interfaz. (Error 4) Procedimiento declarado en múltiples interfaces. (Error 5) Error en los parámetros de la llamada al procedimiento en una determinada interfaz. A continuación mostramos un ejemplo de un programa MP con errores semánticos: INTERFACE m1 p(r:int) p(r:real) g(i:int,j:real) INTERFACE m2 p(r:real) g(i:real,j:int) h() { a,b,c:int x,y,z:real m3.p(x) (Error 1) Interfaz m3 no declarada h() r() (Error 3) Procedimiento r no declarado en ninguna interfaz m1.p(a) p(x) (Error 4) Procedimiento p declarado en múltiples interfaces m1.p(x-1.0) m2.h() m1.h() (Error 2) Procedimiento h no declarado en interfaz m1 m1.g(b,y+1) m2.g(a,x) (Error 5) Error en los parámetros de la llamada al procedimiento g en interfaz m2 m2.g(e,x) (Error 5) Error en los parámetros de la llamada al procedimiento g en interfaz m2 Los errores deben ser informados por consola siguiendo el formato mostrado para el programa de ejemplo. Descripciones a entregar: [DISEÑO ABSTRACTO] (3 puntos) Diseño abstracto del analizador semántico. Use la gramática dada en el Anexo.

4 header{ import java.io.* import java.util.* class AnasemMP extends TreeParser tokens{ TIPOINDEF { almacen para variables (variables): se almacenará el nombre y el tipo de cada variable almacen para las interfaces (interfaces): se almacenará para cada interfaz, sus procedimientos. Cada procedimiento debe almacenar nombre y un conjunto de listas para los tipos de sus parámetros. memorizar_interfaz(interfaz): almacena una interfaz sin procedimientos. memorizar_variable(var, tipo): almacena una variable con su tipo memorizar_procedimiento(interfaz, procedimiento, tipos): almacena un procedimiento con la lista de tipos correspondiente a sus parámetros en la interfaz dada. comprobar_procedimiento(procedimiento, tipos): comprueba en cuántas interfaces ocurre el procedimiento dado considerando sus parámetros. Permite detectar y emitir mensajes de Error 3 y Error 4. comprobar_procedimiento_en_interfaz(interfaz, procedimiento, tipos): comprueba si un procedimiento dado está declarado en una interfaz considerando sus parámetros. Permite detectar y emitir mensajes de Error 5, Error 1 y Error 2. calcular_tipo_operacion(tipo1,tipo2): calcula el tipo una operación binaria. calcular_tipo_variable(var): calcula el tipo de una variable accediendo al almacen de variables. programa : #(PROGRAMA interfaces bloque) interfaces : (interfaz)+ interfaz : #(INTERFACE interfaz:ident {memorizar_interfaz(interfaz) (procedimiento[interfaz])+) procedimiento[interfaz] : #(PROCEDIMIENTO procedimiento:ident tipos=parametros) {memorizar_procedimiento(interfaz, procedimientos, tipos) parametros returns [Lista de tipos] : (tipo=parametro {añadir tipo a la lista tipos)* parametro returns [t]: #(IDENT t=tipo) tipo returns [t]: a:entero {t=entero b:real {t=real bloque : #(BLOQUE variables instrucciones) variables : #(VARIABLES (vars)+) instrucciones : #(INSTRUCCIONES (instruccion)+)

5 vars : #(ENTERO (var:ident {memorizar_variable(var, entero))+) #(REAL (var:ident {memorizar_variable(var, real))+) instruccion : #(PUNTO interfaz:ident procedimiento:ident (tipos=lista_exprs)?) {comprobar_procedimiento_en_interfaz(interfaz, procedimiento, tipos) #(procedimiento:ident (tipos=lista_exprs)?) {comprobar_procedimiento(procedimiento, tipos) lista_exprs returns [Lista de tipos] : (tipo=expr {añadir tipo a la lista tipos)+ expr returns [tipo] : #(MAS t1=expr t2=expr){tipo=calcular_tipo_operacion(t1,t2) #(MENOS t1=expr t2=expr){tipo=calcular_tipo_operacion(t1,t2) #(POR t1=expr t2=expr){tipo=calcular_tipo_operacion(t1,t2) #(DIV t1=expr t2=expr){tipo=calcular_tipo_operacion(t1,t2) var:ident {tipo=calcular_tipo_variable(var) NENTERO {t=entero NREAL {t=real [IMPLEMENTACIÓN] Atribuir la gramática Antlr dada en el Anexo con una implementación del diseño abstracto. header{ import java.io.* import java.util.* class AnasemMP extends TreeParser tokens{ TIPOINDEF { Map<String,Integer> variables = new HashMap<String,Integer>() Map<String,Map<String,Set<List<Integer>>>> interfaces = new HashMap<String,Map<String,Set<List<Integer>>>>() void memorizar_interfaz(string interfaz){ Map<String,Set<List<Integer>>>aux = new HashMap<String,Set<List<Integer>>>() interfaces.put(interfaz,aux) System.out.println("Interfaz "+interfaz+" procesada") void memorizar_variable(string var, Integer tipo){ variables.put(var,tipo) System.out.println("Variable "+var+" procesada") void memorizar_procedimiento(string interfaz, String procedimiento, List<Integer> tipos){ Map<String,Set<List<Integer>>> i_aux = interfaces.get(interfaz) Set<List<Integer>> s_aux = i_aux.get(procedimiento) if (s_aux==null) s_aux = new HashSet<List<Integer>>() s_aux.add(tipos) i_aux.put(procedimiento,s_aux) interfaces.put(interfaz,i_aux) for(list<integer>l:s_aux) System.out.println("Procedimiento "+procedimiento+"("+l.tostring()+")"+

6 " en interfaz "+interfaz+" procesado") void mostrar_interfaces(){ System.out.println(interfaces) void mostrar_variables(){ System.out.println(variables) void comprobar_procedimiento(string procedimiento, List<Integer> tipos){ boolean resultado = false Set<String> keys = interfaces.keyset() Iterator<String> it1 = keys.iterator() int cont=0 while(it1.hasnext()){ if (comprobar_procedimiento_en_interfaz_aux(it1.next(),procedimiento,tipos)==0) cont++ if (cont==0) System.out.println("(Error 3) Procedimiento "+procedimiento+" no declarado en ninguna interfaz") if (cont>1) System.out.println("(Error 4) Procedimiento "+procedimiento+" declarado en múltiples interfaces") int comprobar_procedimiento_en_interfaz_aux(string interfaz, String procedimiento, List<Integer> tipos){ int error = 0 if (interfaces.keyset().contains(interfaz)){ Map<String,Set<List<Integer>>> procedimientos = interfaces.get(interfaz) if (procedimientos.keyset().contains(procedimiento)){ Set<List<Integer>>perfiles = procedimientos.get(procedimiento) Iterator<List<Integer>> it = perfiles.iterator() boolean encontrado=false while (it.hasnext() &!encontrado){ List<Integer> perfil = it.next() if (perfil.equals(tipos)) encontrado = true if (!encontrado) error = 5 else error = 2 else error = 1 return error void comprobar_procedimiento_en_interfaz(string interfaz, String procedimiento, List<Integer> tipos){ //System.out.println("(comprobar_procedimiento_en_interfaz) "+interfaz+ // " "+procedimiento+" "+tipos) int error = comprobar_procedimiento_en_interfaz_aux(interfaz,procedimiento,tipos) switch(error){ case 1: System.out.println("(Error 1) Interfaz "+interfaz+" no declarada") break case 2: System.out.println("(Error 2) Procedimiento "+procedimiento+ " no declarado en interfaz "+interfaz) break case 5: System.out.println("(Error 5) Error en los parámetros de la llamada al procedimiento "+procedimiento+

7 " en interfaz "+interfaz)break default: break Integer calcular_tipo_operacion(integer tipo1,integer tipo2){ Integer tipo = TIPOINDEF if (tipo1 == TIPOINDEF tipo2 == TIPOINDEF) tipo = TIPOINDEF else if (tipo1==real tipo2 == REAL) tipo=real else tipo=entero return tipo Integer calcular_tipo_variable(string var){ Integer tipo = TIPOINDEF if (variables.get(var)==null) System.out.println("Variable "+var+" no declarada") else tipo=variables.get(var) return tipo programa : #(PROGRAMA interfaces {mostrar_interfaces() bloque) interfaces : (interfaz)+ interfaz : #(INTERFACE a:ident {memorizar_interfaz(a.gettext()) (procedimiento[a.gettext()])+) procedimiento[string interfaz] {List<Integer> tipos: #(PROCEDIMIENTO a:ident tipos=parametros) {memorizar_procedimiento(interfaz, a.gettext(), tipos) parametros returns [List<Integer> tipos = new LinkedList<Integer>()] {Integer t: (t=parametro {tipos.add(t))* parametro returns [Integer t=null]: #(IDENT t=tipo) tipo returns [Integer t=null]: a:entero {t=new Integer(a.getType()) b:real {t=new Integer(b.getType()) bloque : #(BLOQUE variables {mostrar_variables() instrucciones) variables : #(VARIABLES (vars)+) instrucciones : #(INSTRUCCIONES (instruccion)+) vars : #(ENTERO (a:ident {memorizar_variable(a.gettext(), ENTERO))+) #(REAL (b:ident {memorizar_variable(b.gettext(), REAL))+) instruccion {List<Integer> tipos=new LinkedList<Integer>(): #(PUNTO i:ident p:ident (tipos=lista_exprs)?) {comprobar_procedimiento_en_interfaz(i.gettext(), p.gettext(), tipos) #(q:ident (tipos=lista_exprs)?) {comprobar_procedimiento(q.gettext(), tipos) lista_exprs returns [List<Integer> tipos = new LinkedList<Integer>()]

8 {Integer tipo: (tipo=expr {tipos.add(tipo))+ expr returns [Integer t = TIPOINDEF] {Integer t1,t2: #(MAS t1=expr t2=expr){t=calcular_tipo_operacion(t1,t2) #(MENOS t1=expr t2=expr){t=calcular_tipo_operacion(t1,t2) #(POR t1=expr t2=expr){t=calcular_tipo_operacion(t1,t2) #(DIV t1=expr t2=expr){t=calcular_tipo_operacion(t1,t2) a:ident {t=calcular_tipo_variable(a.gettext()) NENTERO {t=entero NREAL {t=real Anexo header{ import java.io.* import java.util.* class AnasemMP extends TreeParser tokens{ TIPOINDEF programa : #(PROGRAMA interfaces bloque) interfaces : (interfaz)+ interfaz : #(INTERFACE IDENT (procedimiento)+) procedimiento: #(PROCEDIMIENTO IDENT parametros) parametros: (parametro)* parametro: #(IDENT tipo) tipo: ENTERO REAL bloque : #(BLOQUE variables instrucciones) variables : #(VARIABLES (vars)+) instrucciones : #(INSTRUCCIONES (instruccion)+) vars : #(ENTERO (IDENT)+) #(REAL (IDENT)+) instruccion: #(PUNTO IDENT IDENT (lista_exprs)?) #(IDENT (lista_exprs)?) lista_exprs: (expr)+ expr: #(MAS expr expr) #(MENOS expr expr) #(POR expr expr) #(DIV expr expr) IDENT NENTERO NREAL

9 PROCESADORES DEL LENGUAJES Septiembre 2017 NOMBRE: GRUPO: EL LENGUAJE COND1 COND1 es un lenguaje de programación. El programa COND1 consta de declaraciones de variables enteras y secuencia de instrucciones. Las instrucciones en COND1 son de cuatro tipos: asignación, instrucción condicional, impresión por pantalla de variables y ruptura de control. A continuación se muestran dos programas COND1 junto a la impresión por pantalla generada por sus respectivas interpretaciones: PROGRAMA VARIABLES x,y INSTRUCCIONES x = 1 y = 2 mostrar(x,y) si (x>y) entonces ruptura x=y sino x=y mostrar(x,y) ruptura si (x==y) entonces x=10 y=20 finsi finsi mostrar(x,y) (mostrar) x = 1 y = 2 (mostrar) x = 2 y = 2 (mostrar) x = 2 y = 2 PROGRAMA VARIABLES x,y INSTRUCCIONES x = 1 y = 2 mostrar(x,y) si (x<y) entonces ruptura x=y sino x=y mostrar(x,y) ruptura si (x==y) entonces x=10 y=20 finsi finsi mostrar(x,y) (mostrar) x = 1 y = 2 (mostrar) x = 1 y = 2 Interpretación basada en las siguientes restricciones: La declaración de variables inicializa éstas al valor 0. Las instrucciones se ejecutan secuencialmente. La asignación de un valor a una variable se realiza con el operador =. Las expresiones aritméticas pueden utilizar operadores suma, resta y multiplicación. Las expresiones booleanas o condiciones pueden utilizar el operador de igualdad, mayor, menor, mayor o igual, menor o igual y distinto. La ejecución de una instrucción condicional implica evaluar la condición y ejecutar el bloque de instrucciones correspondiente. La instrucción de ruptura provoca la interrupción en la ejecución del bloque de instrucciones en el que ocurre la ruptura. Las impresiones por pantalla tienen como argumento una secuencia de variables. La impresión muestra el valor de las variables correspondientes. Por ejemplo, mostrar(x,y)mostrará un mensaje del tipo (mostrar) x=..., y=...

10 SE PIDE: Intérprete de programas COND1 (suponemos los programas sin errores). (3 puntos) Descripciones a entregar: [DISEÑO ABSTRACTO] Diseño abstracto del intérprete. Use la gramática dada en el Anexo. class InterpreteCOND1 extends TreeParser { memoria_variables: almacena para cada variable, su valor asignar(var,num): almacena el valor num en variable var consultar(var): consulta en memoria_variables el valor de variable var mostrar(vars): mostrar el valor de las vaiables vars Se usarán centinelas para controlar la interpretaciónde instrucciones. El valor cierto indica que se debe interpretar y el falso que no se debe interpretar. programa : #(PROGRAMA variables instrucciones[centinela inicialmente cierto]) variables : #(VARIABLES (lista_vars)?) lista_vars : (var:var {asignar(var,0))+ instrucciones[centinela] : #(INSTRUCCIONES (lista_instrs[centinela])?) lista_instrs[centinela] : centinela_aux=instruccion[centinela] (lista_instrs[centinela & centinela_aux])? instruccion[centinela_b] returns [centinela_r]: asignacion[centinela_b] {centinela_r=centinela_b condicional[centinela_b] {centinela_r=centinela_b ruptura[centinela_b] {centinela_r=false impresion[centinela_b] {centinela_r=centinela_b asignacion[centinela_b] : #(ASIG var:var valor=expr) {if (centinela_b) asignar(var,valor) condicional[centinela_b] : #(SI centinela_aux=condicion lista_instrs[centinela_b & centinela_aux] (alternativa[b&!aux])?) alternativa[centinela_b] : #(SINO lista_instrs[centinela_b]) ruptura[centinela_b] : RUPTURA impresion[centinela_b] : #(MOSTRAR vars){if (centinela_b) mostrar(vars) vars : (VAR)+ condicion returns[r] : #(MAYOR r1=expr r2=expr){r=(r1>r2) #(MENOR r1=expr r2=expr){r=(r1<r2) #(IGUAL r1=expr r2=expr){r=(r1==r2) #(DISTINTO r1=expr r2=expr){r=(r1!=r2) #(MAYORIGUAL r1=expr r2=expr){r=(r1>=r2)

11 #(MENORIGUAL r1=expr r2=expr){r=(r1<=r2) expr returns[r] : #(MAS r1=expr1 r2=expr){r=(r1+r2) #(MENOS r1=expr1 r2=expr){r=(r1-r2) #(POR r1=expr1 r2=expr){r=(r1*r2) r=expr1 expr1 returns[r] : VAR {r=consultar(var) NUM {r=valor correspodiente a text NUM [IMPLEMENTACIÓN] Atribuir la gramática del Anexo con una implementación del diseño abstracto. header{ import java.util.* class InterpreteCOND1 extends TreeParser { Map<String,Integer>memoria_variables = new HashMap<String,Integer>() void asignar(string var,integer num){ //System.out.println("(asignar)"+" "+var+" "+num) memoria_variables.put(var, num) Integer consultar(string var){ return memoria_variables.get(var) void mostrar(ast vars){ System.out.println("(mostrar)") AST it=vars while (it!=null){ System.out.println(it.getText()+ " = "+memoria_variables.get(it.gettext())) it = it.getnextsibling() programa : #(PROGRAMA variables instrucciones[true]) variables : #(VARIABLES (lista_vars)?) lista_vars : (a:var {asignar(a.gettext(),0))+ instrucciones[boolean centinela] : #(INSTRUCCIONES (lista_instrs[centinela])?) lista_instrs[boolean centinela] {boolean aux: aux=instruccion[centinela] (lista_instrs[centinela&aux])? instruccion[boolean b] returns [boolean r = true]: asignacion[b] {r=b condicional[b] {r=b ruptura[b] {r=false impresion[b] {r=b asignacion[boolean b] {Integer r : #(ASIG a:var r=expr) {if (b) asignar(a.gettext(),r)

12 condicional[boolean b] {boolean aux: #(SI aux=condicion lista_instrs[b&aux] (alternativa[b&!aux])?) alternativa[boolean b] : #(SINO lista_instrs[b]) ruptura[boolean b] : RUPTURA impresion[boolean b] : #(MOSTRAR l:vars){if (b) mostrar(l) vars : (VAR)+ condicion returns[boolean r=true] {Integer r1,r2: #(MAYOR r1=expr r2=expr){r=(r1>r2) #(MENOR r1=expr r2=expr){r=(r1<r2) #(IGUAL r1=expr r2=expr){r=(r1==r2) #(DISTINTO r1=expr r2=expr){r=(r1!=r2) #(MAYORIGUAL r1=expr r2=expr){r=(r1>=r2) #(MENORIGUAL r1=expr r2=expr){r=(r1<=r2) expr returns[integer r=0] {Integer r1,r2: #(MAS r1=expr1 r2=expr){r=(r1+r2) #(MENOS r1=expr1 r2=expr){r=(r1-r2) #(POR r1=expr1 r2=expr){r=(r1*r2) r=expr1 expr1 returns[integer r=0] : a:var {r=consultar(a.gettext()) b:num {r=new Integer(b.getText()) Aprovechando el diseño del intérprete, SE PIDE: Compilador que genere programas COND1 equivalentes sin instrucciones condicionales e instrucciones de ruptura. (1 punto) Por ejemplo, el programa equivalente al primer programa de ejemplo es: PROGRAMA VARIABLES x,y INSTRUCCIONES x = 1 y = 2 mostrar(x,y) x=y mostrar(x,y) mostrar(x,y) Descripciones a entregar: [DISEÑO ABSTRACTO] Diseño abstracto del compilador. Use la gramática dada en el Anexo. class CompiladorCOND1 extends TreeParser { memoria_variables: almacena para cada variable, su valor asignar(var,num): almacena el valor num en variable var consultar(var): consulta en memoria_variables el valor de variable var

13 Se usarán centinelas para controlar la compilación de instrucciones. El valor cierto indica que se debe compilar y el falso que no se debe compilar. Fichero f abrir_fichero(): abrir fichero f cerrar_fichero(): cerrar fichero f escribir_fichero(texto): escribir texto en fichero f convertir(expr): convertir el ASA expr en un texto escribir_programa(): escribir inicio del programa COND1 escribir_variables(vars): escribir variables vars escribir_instrucciones(): escribir comienzo de instrucciones del programa COND1 escribir_asignacion(var, expr): escribir una instrucción de asignación compuesta de variable var y expresión expr. escribir_mostrar(vars): escribir instrucción mostrar. programa : #(PROGRAMA {abrir_fichero() escribir_programa() variables instrucciones[centinela con valor cierto]) {cerrar_fichero() variables : #(VARIABLES (lista_vars)? {escribir_variables(lista_vars)) lista_vars : (var:var {asignar(var,0))+ instrucciones[centinela] : #(INSTRUCCIONES {escribir_instrucciones() (lista_instrs[centinela])?) lista_instrs[centinela] : centinela_aux=instruccion[centinela] (lista_instrs[centinela & centinela_aux])? instruccion[centinela_b] returns [centinela_r]: asignacion[centinela_b] {centinela_r=centinela_b condicional[centinela_b] {centinela_r=centinela_b ruptura[centinela_b] {centinela_r=false impresion[centinela_b] {centinela_r=centinela_b asignacion[centinela_b] : #(ASIG var:var valor=expr) {if (centinela_b) { asignar(var,valor) escribir_asignacion(var, convertir(expr)) condicional[centinela_b] : #(SI centinela_aux=condicion lista_instrs[centinela_b & centinela_aux] (alternativa[centinela_b &!centinela_aux])?) alternativa[centinela_b] : #(SINO lista_instrs[centinela_b]) ruptura[centinela_b] : RUPTURA impresion[centinela_b] : #(MOSTRAR vars){if (centinela_b) {escribir_mostrar(vars) vars : (VAR)+ condicion returns[r] : #(MAYOR r1=expr r2=expr){r=(r1>r2) #(MENOR r1=expr r2=expr){r=(r1<r2)

14 #(IGUAL r1=expr r2=expr){r=(r1==r2) #(DISTINTO r1=expr r2=expr){r=(r1!=r2) #(MAYORIGUAL r1=expr r2=expr){r=(r1>=r2) #(MENORIGUAL r1=expr r2=expr){r=(r1<=r2) expr returns[r] : #(MAS r1=expr1 r2=expr){r=(r1+r2) #(MENOS r1=expr1 r2=expr){r=(r1-r2) #(POR r1=expr1 r2=expr){r=(r1*r2) r=expr1 expr1 returns[r] : var:var {r=consultar(var) num:num {r=convertir a texto num [IMPLEMENTACIÓN] Atribuir la gramática del Anexo con una implementación del diseño abstracto. header{ import java.util.* import java.io.* class CompiladorCOND1 extends TreeParser { Map<String,Integer>memoria_variables = new HashMap<String,Integer>() void asignar(string var,integer num){ //System.out.println("(asignar)"+" "+var+" "+num) memoria_variables.put(var, num) Integer consultar(string var){ return memoria_variables.get(var) FileWriter f void abrir_fichero(){ try{ f = new FileWriter("./resultado.txt") catch(ioexception e){system.out.println(e.tostring()) void cerrar_fichero(){ try{ f.close() catch(ioexception e){system.out.println(e.tostring()) void escribir_fichero(string s){ try{ f.write(s) //System.out.print(s) catch(ioexception e){system.out.println(e.tostring()) void escribir_espacios(){ try{ for(int i=0i<espaciosi++){ f.write(' ') System.out.print(' ') catch(ioexception e){system.out.println(e.tostring())

15 int espacios = 0 String convertir(ast expr){ String resultado = new String() switch(expr.gettype()){ case MAS: resultado = "("+convertir(expr.getfirstchild())+"+"+ convertir(expr.getfirstchild().getnextsibling())+")" break case MENOS: resultado = "("+convertir(expr.getfirstchild())+"-"+ convertir(expr.getfirstchild().getnextsibling())+")" break case POR: resultado = convertir(expr.getfirstchild())+"*"+ convertir(expr.getfirstchild().getnextsibling()) break case NUM: case VAR: resultado = expr.gettext() break default: break return resultado void escribir_programa(){ escribir_espacios() String r = new String("PROGRAMA\n") escribir_fichero(r) void escribir_variables(ast vars){ escribir_espacios() String r = new String("VARIABLES\n") escribir_fichero(r) if (vars!=null){ espacios+=3 escribir_espacios() AST it = vars while (it!=null){ r = new String(it.getText()) it = it.getnextsibling() if (it!=null) r=r+"," escribir_fichero(r) r="\n" escribir_fichero(r) espacios-=3 void escribir_instrucciones(){ escribir_espacios() String r = new String("INSTRUCCIONES\n") escribir_fichero(r) espacios+=3 void escribir_asignacion(string var, String expr){ escribir_espacios() String r = new String(var+"="+expr+"\n") escribir_fichero(r) void escribir_mostrar(ast vars){ escribir_espacios() String r= new String("mostrar(")

16 AST it = vars while (it!=null){ r=r+it.gettext() it=it.getnextsibling() if (it!=null) r=r+"," r=r+")\n" escribir_fichero(r) programa : #(PROGRAMA {abrir_fichero() escribir_programa() variables instrucciones[true]) {cerrar_fichero() variables : #(VARIABLES (l:lista_vars)? {escribir_variables(l)) lista_vars : (a:var {asignar(a.gettext(),0))+ instrucciones[boolean centinela] : #(INSTRUCCIONES {escribir_instrucciones() (lista_instrs[centinela])?) lista_instrs[boolean centinela] {boolean aux: aux=instruccion[centinela] (lista_instrs[centinela&aux])? instruccion[boolean b] returns [boolean r = true]: asignacion[b] {r=b condicional[b] {r=b ruptura[b] {r=false impresion[b] {r=b asignacion[boolean b] {Integer r : #(ASIG a:var r=c:expr) {if (b) { asignar(a.gettext(),r) escribir_asignacion(a.gettext(), convertir(c)) condicional[boolean b] {boolean aux: #(SI aux=condicion lista_instrs[b&aux] (alternativa[b&!aux])?) alternativa[boolean b] : #(SINO lista_instrs[b]) ruptura[boolean b] : RUPTURA impresion[boolean b] : #(MOSTRAR l:vars){if (b) {escribir_mostrar(l) vars : (VAR)+ condicion returns[boolean r=true] {Integer r1,r2: #(MAYOR r1=expr r2=expr){r=(r1>r2) #(MENOR r1=expr r2=expr){r=(r1<r2) #(IGUAL r1=expr r2=expr){r=(r1==r2) #(DISTINTO r1=expr r2=expr){r=(r1!=r2) #(MAYORIGUAL r1=expr r2=expr){r=(r1>=r2) #(MENORIGUAL r1=expr r2=expr){r=(r1<=r2) expr returns[integer r=0] {Integer r1,r2: #(MAS r1=expr1 r2=expr){r=(r1+r2) #(MENOS r1=expr1 r2=expr){r=(r1-r2) #(POR r1=expr1 r2=expr){r=(r1*r2) r=expr1 expr1 returns[integer r=0] : a:var {r=consultar(a.gettext()) b:num {r=new Integer(b.getText())

17 Anexo class InterpreteCompilador extends TreeParser programa : #(PROGRAMA variables instrucciones) variables : #(VARIABLES (lista_vars)?) lista_vars : (VAR)+ instrucciones : #(INSTRUCCIONES (lista_instrs)?) lista_instrs : instruccion (lista_instrs)? instruccion : asignacion condicional ruptura impresion asignacion : #(ASIG VAR expr) condicional: #(SI condicion lista_instrs (alternativa)?) alternativa : #(SINO lista_instrs) ruptura : RUPTURA impresion : #(MOSTRAR vars) vars : (VAR)+ condicion : #(MAYOR expr expr) #(MENOR expr expr) #(IGUAL expr expr) #(DISTINTO expr expr) #(MAYORIGUAL expr expr) #(MENORIGUAL expr expr) expr : #(MAS expr1 expr) #(MENOS expr1 expr) #(POR expr1 expr) expr1 expr1 : VAR NUM