PROGRAMACION DE SISTEMASJJTREE y JavaCC

Introducción• JJTree, es una herramienta para

construir un árbol de representación del mismo parser.

• JJTree se acciona para emitir un parser el cual su principal trabajo durante su ejecución no es ejecutar acciones incrustadas de java, sino construir una representación independiente de árbol del análisis sintáctico de la expresión que se analiza por el compilador resultante.

¿Qué hacer con el árbol que produce JJTree?• JJTree permite capturar el estado

de la sesión del análisis sintáctico en un solo árbol que es fácil de recorrer y verificar en tiempo de ejecución, independientemente del código de análisis sintáctico que lo produce.

Arbol de análisis sintáctico• Al árbol generado por JJTree, se le

denomina formalmente como Árbol de análisis sintáctico.

• Para trabajar con JJTree se requiere lo siguiente:– Crear un script con extensión .jjt el

cual JJTree toma como entrada– Escribir el código del lado cliente

para recorrer y evaluar el árbol sintáctico que se produce en la ejecución.

Aspectos básicos de JJTree• JJTree es un preprocesador y

genera un parser para un BNF particular.

• Es un proceso fácil de dos pasos:– Ejecutar JJTree contra un archivo

denominado .jjt; este producirá un archivo .jj

– Compilar el archivo .jj con JavaCC– Y por último, compilar el archivo .java

resultante

Sintaxis del archivo .jjt• La estructura de un archivo .jjt es de

menor extensión que el formato .jj• La principal diferencia es que JJTree

agrega un nuevo constructor sintáctico (node-constructor) el cual permite especificar donde y bajo que condiciones se tienen que generar los nodos del árbol sintáctico durante el análisis sintáctico.

Una gramática simpleSKIP:{“ “|”\t”|”\n”|”\r” }

TOKEN:{<INT : ([“0”-”9”])+ > }

void simpleLeng():{} {addExpr() <EOF>}

void addExpr():{} {integerLit() (“+” integerLit() ) ? }

void integerLit():{} {<INT>}

• En ésta gramática se establece que una expresión válida consiste de:– Una sola literal entera o– Una literal entera seguida del signo más y seguido por otra literal entera.

• A continuación, ligeramente modificada para emplear JJTree (se indican los cambios)

SKIP:{“ “|”\t”|”\n”|”\r” }

TOKEN:{<INT : ([“0”-”9”])+ > }

SimpleNode simpleLeng():#Root{} {addExpr()<EOF> {return jjtThis;}}

void addExpr():{} {integerLit()

(“+” integerLit() #Add(2) ) ? }

void integerLit():#IntLit{} {<INT>}

Paso a paso por la gramática JJTree• La invocación a un parser sin

emplear JJTree sería como:SimpleParser parser = new SimpleParser(new StringReader(expresion));

parser.simpleLeng();

• Ahora la invocación a un parser empleando JJTree:SimpleParser parser = new SimpleParser(new StringReader(expresion));

SimpleNode rootNode = parser.simpleLeng();

Descripción del ejemplo• Las etiqueta insertada de la

forma #Root, indican que se insertará un nodo raíz (de tipo SimpleNode) en el árbol creado y referenciado en todo momento por jjtThis.

SimpleNode simpleLeng():#Root{}

{addExpr()<EOF> {return jjThis;}}

Descripción del ejemplo• La etiqueta #Add(2) dentro de la producción

addExpr() difiere de la etiqueta #Root en varios aspectos:– Es parametrizada. El constructor del árbol utiliza

una pila de nodos durante la construcción; el comportamiento normal para un constructor de nodos sin parámetros es colocarse en el tope del árbol sintáctico bajo construcción, sacando todos los nodos de la pila de nodos que fueron creados en su mismo alcance y colocando a dicho nodo como el nodo padre.

– El argumento 2 indica que el nuevo nodo padre (en éste caso #Add) adoptará exactamente dos nodos hijo, los dos sub nodos #IntLit descritos en la siguiente construcción.

Descripción del ejemplo• De igual importancia, la colocación de la

directiva #Root fuera del cuerpo de la producción significa que el nodo #Root es generado cada vez que se cumple la producción (lo cual en éste caso sólo sucede una vez).

• Sin embargo, la colocación de la directiva #Add(2) dentro de un término “cero o uno” significa que un nodo #Add se crea condicionalmente si la cláusula opcional se cumple, es decir si ésta producción representa una verdadera operación de suma.

Descripción del ejemplo• Siguiendo las reglas de producción, integerLit() se cumple dos veces, agregando al árbol un nodo #IntLit en cada invocación. Ambos nodos #IntLit se convierten en nodos hijos del nodo #Add que los invoca. Sin embargo si la expresión a analizar sintácticamente es de un solo entero, entonces el nodo resultante se convierte directamente en nodo hijo de #Root

Representación del árbol• Árbol sintáctico para una expresión de un

solo entero.

• Árbol sintáctico para una operación de suma.

Trabajando sobre el árbol resultante• Cada nodo que se declara en un archivo .jjt

instruye al parser a generar una subclase del tipo SimpleNode de JJTree.

• SimpleNode en turno, implementa una interface Java denominada Node.

• Los archivos fuente para estas clases son generadas automáticamente por cada archivo JJTree, acompañando al archivo .jj

• JJTree también emite archivos fuente para sus propias clases – Root, Add y IntLit del ejemplo – así como otras clases de apoyo.

Desplegando el contenido del árbol.• Todas las subclases de SimpleNode

heredan un comportamiento útil. El método dump() de SimpleNode es uno de estos.

• Las siguientes tres líneas de código inician el parser, lo invocan, obtienen en árbol sintáctico e imprimen directamente una representación textual del árbol en la consola.

Trabajando sobre el árbol resultante• Código dentro del método main() o método de la

clase “Cliente” del parser.

SimpleParser parser = new SimpleParser(new StringReader(expresion));

SimpleNode rootNode = parser.simpleLeng();

rootNode.dump(“ “);

• Representación del árbol de acuerdo al ejemplo

Root

Add

IntLit

IntLit

Navegando a través del árbol• Otro método útil de SimpleNode

es jjtGetChild(int). • De acuerdo al ejemplo, cuando se

navega a través del árbol sintáctico y se encuentre un nodo #Add, seguramente se buscará obtener sus nodos hijos tipo #IntLit, extraer sus valores enteros que representan y sumarlos.

Navegando a través del árbol• Asumiendo que addNode, mostrado en

el siguiente fragmento de código, es una variable que representa un nodo de tipo Add, podemos acceder a los dos nodos hijos de addNode.

SimpleNode izq = addNode.jjtGetChild(0);SimpleNode der = addNode.jjtGetChild(1);

Es importante aclarar que los dos nodos IntLit todavía no contienen los valores enteros que pretenden representar.

Almacenando y recuperando el estado.• Para almacenar el valor de los

tokens identificados en los nodos apropiados, hay que realizar las siguientes modificaciones a SimpleNode:

public class SimpleNode extends Node{String m_text;public void setText(String text) {m_text = text;}public String getText() { return m_text; }

}

Almacenar y recuperar el estado.• Cambiar la siguiente producción en el

archivo .jjtvoid integerLit(): #IntLit {} {<INT>}

• por éstovoid integerLit(): #IntLit {Token t}

{ t=<INT>{ jjtThis.setText(t.image);} }

Esta producción obtiene el texto crudo del valor del entero encontrado en t.image y usa el método setText() para almacenar la cadena en el nodo actual.

Desplegando los cambios• Fácilmente se puede modificar el

método SimpleNode.dump() para emitir el valor de m_text para cualquier nodo que sea almacenado durante el análisis.

• Por ejemplo, se puede modificar para visualizar la salida de dump(), para la expresión “42 + 1” y obtener el siguiente resultado:

Root Add

IntLit[42]IntLit[1]

Implementando la precedencia de operadores.• Ordenando correctamente las

reglas de producción, colocando en la parte inferior aquellas reglas que tienen mayor prioridad, se cubre la precedencia de los operadores ya que la representación del árbol sintáctico controlará efectivamente el orden correcto de evaluación.

Ejemplo completo.• Revisar el archivo Calc.jjt y

realizar las siguientes modificaciones: