Traductores DDS con CUP

Transcripción

1 Gramática para reconocer expresiones lógicas. Resultado: valor de verdad (true false) A::= L semicolon A L semicolon; L::= L opand J L opor J L opnand J L opnor J L opxor J L opxnor J J; J::= apertura_parentesis L cierre_parentesis vtrue vfalse opnot apertura_parentesis L cierre_parentesis C; C::=numero opigual numero numero opdist numero numero opmenor numero numero opmayor numero numero opmenori numero numero opmaypri numero;

2 DDS con CUP: uso de acciones semánticas con atributos sintetizados. Al ser expresiones sólo booleanas, no creamos la clase java Simbolo que almacene el tipo de la variable que sintetizamos: definimos variables Boolean en los No Terminales. L, J y C siempre devolverán true o false non terminal A; non terminal Boolean L, J, C;

3 Comenzamos desde las hojas del árbol subiendo los valores de verdad hasta llegar a la raíz para devolver el resultado de la expresión. Ejemplo : (23 == 4) and true; Árbol asociado:

4 (23 == 4) and true; En el no terminal C debe evaluarse la expresión a false y transmitirse a los no terminales superiores con un atributo sintetizado. Variable RESULT contiene un BOOLEAN

5 En el no terminal C de la gramática se insertan las acciones semánticas que calculan la operación: En el resto de operadores (opdist, opmayor,etc) se opera de manera análoga C ::= numero:n1 opigual numero:n2 {: int v1=integer.parseint(n1); int v2=integer.parseint(n2);.. ; boolean b= (v1 == v2); RESULT=b; :}

6 (false) and true; El valor de RESULT en C se sube por el árbol hasta que otro nodo lo necesite para operar; es decir, pasa por J, L, otra vez J y otra vez L hasta el primer L, el cual hará la operación AND.

7 Aquellas producciones de la gramática que no tienen que realizar cálculos de expresiones, almacenarán en RESULT el valor de su consecuente y lo subirán por el árbol: J ::= apertura_parentesis L:l cierre_parentesis {: RESULT=l; :} C:c {: RESULT=c; :} ; L::= J:j {: RESULT=j; :} ;

8 En la producción de J que niega lo que le viene del no terminal L, se debe devolver el valor contrario al recibido: J ::= opnot apertura_parentesis L:l cierre_parentesis {:RESULT=! (l); :}

9 false and true; Para realizar la operación AND hace falta el valor del segundo parámetro, J. Se sube por el árbol el contenido del terminal vtrue.

10 En la gramática, cuando se tiene la producción de J en la que se insertan los valores true o false, estos se devuelven con el atributo RESULT: J ::=.. vtrue {: RESULT=true; :} vfalse {: RESULT=false; :}..

11 false; Ahora que L tiene los valores de los parámetros de la expresión, calcula el resultado y lo sintetiza con RESULT.

12 En la gramática, a aquellas producciones de L que realizan operaciones booleanas se les inserta el código Java equivalente a la acción deseada para devolver el valor con RESULT. Con el resto de operaciones (nor, nand, etc) se procede de manera análoga: L ::= L:l opand J:j {: boolean b= (l && j); RESULT=b; :}.. ;

13 Finalmente, se le pasa el valor de RESULT al axioma A. Se muestra el resultado por pantalla. Como no hay más derivaciones tras el ;, se termina la ejecución.

14 El axioma es el encargado de mostrar el resultado por pantalla, ya que los atributos son sintetizados y el valor final lo tendrá la raíz del árbol. A A no se le pasa ningún valor porque las expresiones booleanas son independientes. A ::= L:l semicolon {: System.out.println("\n\nExpresion logica correcta. Valor final: "+ l + "\n\n"); :} A L:l semicolon {: System.out.println("\n\nExpresion logica correcta. Valor final: "+ l + "\n\n"); :};

15 Finalmente, la gramática con el traductor queda así: A ::= L:l semicolon {: System.out.println("\n\nExpresion logica correcta. Valor final: "+ l + "\n\n"); :} A L:l semicolon {: System.out.println("\n\nExpresion logica correcta. Valor final: "+ l + "\n\n"); :}; L ::= L:l opand J:j {: boolean b= (l && j); RESULT=b; :} L:l opor J :j {:boolean b= (l j); RESULT=b;:} L:l opnand J:j {:boolean b=!(l && j); RESULT=b;:}

16 Finalmente, la gramática con el traductor queda así: L ::= L:l opnor J:j {:boolean b=!(l j); RESULT=b; :} L:l opxor J:j {:boolean b= (l ^ j); RESULT=b; :} L:l opxnor J:j {: boolean b=!(l ^ j); RESULT=b; :} J:j {: RESULT=j; :} ; J ::= apertura_parentesis L:l cierre_parentesis {:RESULT=l; :} vtrue {: RESULT=true; :} vfalse {:RESULT=false; :} opnot apertura_parentesis L:l cierre_parentesis {: RESULT=!(l); :} C:c {: RESULT=c; :} ;

17 Finalmente, la gramática con el traductor queda así: C ::= numero:n1 opigual numero:n2 {:int v1=integer.parseint(n1); int v2=integer.parseint(n2); boolean b= (v1 == v2); RESULT=b; :} numero:n1 opdist numero:n2 {: int v1=integer.parseint(n1); int v2=integer.parseint(n2); boolean b= (v1!= v2); RESULT=b; :} numero:n1 opmenor numero:n2 {: int v1=integer.parseint(n1); int v2=integer.parseint(n2); boolean b= (v1 < v2);result=b; :}

18 Finalmente, la gramática con el traductor queda así: C ::= numero:n1 opmayor numero:n2 {:int v1=integer.parseint(n1); int v2=integer.parseint(n2); boolean b= (v1 > v2); RESULT=b; :} numero:n1 opmenori numero:n2 {: int v1=integer.parseint(n1); int v2=integer.parseint(n2); boolean b= (v1 <= v2); RESULT=b; :} numero:n1 opmayori numero:n2 {: int v1=integer.parseint(n1); int v2=integer.parseint(n2); boolean b= (v1 >= v2);result=b; :}