Download Como integrar un Editor al compilador de su

Esta es la seccion dentro del archivo de especificacion de javacc, en la cual se declara la
clase principal del Analizador Lexico-Sintactico, el cual desde ahora le denominaremos
simplemente Compilador.
En los ejemplos anteriores, se incluia el metodo main como el punto inicial para ejecutar
el Compilador, en el archivo .jj.
PARSER_BEGIN(Compilador)
import java.io.FileInputStream;
import java.io.IOException;
public class Compilador{
public static void main(String args[])
throws ParseException {
try {
// Especificaremos un archivo en
// lugar de la entrada por teclado
FileInputStream fin;
fin = new FileInputStream("entrada.txt");
Compilador comp = new Compilador(fin);
comp.Entrada();
}catch(IOException e){
System.out.println("Error");
}
}
}
PARSER_END(Compilador)
Para integrar el editor, tendremos que modificar la espeficiacion de la clase principal del
Compilador ya que lo mandaremos a ejecutar desde el mismo Editor. Quitaremos
entonces el método main(), pero incluiremos dos metodos necesarios para interactuar
con el Editor (addError() y setEditor()).
Esta especificación quedará como sigue (atender a comentarios dentro del codigo) :
options {
STATIC = false; // Esta opcion es importante
// para integrar el Analizador al Editor
}
/* Declaraciones previas */
PARSER_BEGIN(Compilador)
// Aqui se pueden importar los paquetes que sean necesarios
import java.io.FileInputStream;
import java.io.IOException;
import javax.swing.JTextArea;
import javax.swing.JTextPane;
import java.awt.Color;
public class Compilador{
public EditorDoc editor=null; // Variable para referenciar al
// Editor.
public String errores="";
// Con este metodo se le indica al nuestro compilador,
// la referencia al objeto Editor, para que pueda comunicarse
// con este y acceder a sus miembros publicos (vars y metodos)
public void setEditor(EditorDoc ed){
editor = ed;
}
// Aquí otro metodo para reportar los errores y en el caso
// en que se haya especificado un Editor, colocar el mensaje
// de error en el area de texto que corresponda.
public void addError(String err, Token t){
// Si la variable referencia es nula se manda a la
// salida estandar.
if (editor!=null){
errores = errores+err+"\n";
editor.textError.setText(errores);
if (t!=null){
editor.coloreaTexto(t.beginColumn,t.toString().length());
}
} else {
System.out.println(err);
}
}
}
PARSER_END(Compilador)
Guardaremos entonces en el compilador, en una variable la referencia al objeto Editor.
Por otra parte desde el Editor crearemos la instancia de la clase Compilador e
invocaremos al inicio del analisis lexico sintactico invocando el simbolo inicial de la
gramatica, igual que se hacia en el metodo main().
Dentro de la clase editor (EditorDoc.java), cuando se seleccione el invocar al compilador
para revisar el texto de entrada, se invocará el siguiente método, que ahora efectuara
las acciones que hacia antes el metodo main(), ver comentarios dentro del codigo:
// Metodo donde se traslado el main del Compilador.
private void buttonCompilar_actionPerformed(ActionEvent e)
{
// Streams para los flujos de entrada y salida del archivo a revisar
FileInputStream fin;
FileOutputStream fout;
PrintWriter pw;
// Generamos un nombre de archivo “aleatorio”, para crear un temporal.
String archivo = Long.toString(System.currentTimeMillis())+".txt";
// Se escribe en un archivo el texto escrito en el editor, con el nombre antes generado.
try {
fout = new FileOutputStream(archivo);
pw = new PrintWriter(fout);
pw.print(textCodigo.getText());
pw.close();
fout.close();
} catch (IOException ioe) {
textError.setText("Error de escritura en el archivo.");
}
// Ahora se abre para la lectura y asi pasar un flujo de entrada al compilador.
// el siguiente codigo, se encontraba en el metodo main original
try {
Compilador comp;
fin = new FileInputStream(archivo);
// Se crea la instancia del compilador
comp = new Compilador(fin);
// Se le indica al compilador el editor, que en este caso es this.
comp.setEditor(this);
// Se inicia el proceso de analisis lexico-sintactico.
try {
comp.Entrada(); // Invoca al simbolo inicial de la gramatica.
} catch (ParseException pe){
comp.addError("Error en el proceso de Compilacion",null);
}
// se cierra el archivo de entrada.
fin.close();
// Se borra el temporal.
File file = new File(archivo);
if (!file.delete())
comp.addError("No se pudo borrar el archivo = "+archivo,null);
comp=null;
} catch (IOException ioe) {
textError.setText("Error de apertura del archivo.");
}
}
En concreto tienen que referenciar el editor y agregar un metodo de error al compilador
para que escriba los mensajes de error en el cuadro de texto correspondiente, en nuestro
ejemplo el metodo addError y setEditor.
Las lineas que tienen que cambiar en el codigo anterior, se especifican en negritas.
Si no quieren batallar mucho, simplemente agreguen el segundo bloque de codigo en su
archivo *.jj para que su compilador sea la clase “Compilador” y listo.
Generen con javacc los archivos fuente de Java
javacc compilador.jj
y luego compilen todo con
javac Editor.java
Solo tengan cuidado en el archivo fuente EditorDoc.java, invoquen el llamado al simbolo
inical, que en ejemplo es:
comp.Entrada()