JavaCC Tutorial de Rapt - Capítulo 4: Estructura de un Programa en JavaCC

Primero que nada un archivo de JavaCC tiene que llevar la extensión .jj (sólo por gusto y por tratar de seguir un estandar, ya que con que cumpla con la estructura y sea un archivo plano es suficiente) y el nombre que estos tengan no forzosamente debe coincidir con el nombre de la clase JavaCC. Los programas en JavaCC siguen esta estructura general:

En la parte de options se colocan las opciones de JavaCC, es opcional, a partir de PARSER_BEGIN hasta PARSER_END es la declaración del programa en Java, es importante que se entienda que esta parte es código en Java, y que cualquier cosa que aquí se programe es omitido por JavaCC es hasta la compilación en Java que se encuentran los errores de esta parte. Por último, en la parte de producción se colocan las Gramáticas y Expresiones Regulares como lo vimos anteriormente.

JavaCC se encarga de generar lo necesario para complementar esta clase, de forma tal, que cuando se crea una instancia de ésta, se llama al constructor que se le pasa como parámetro el tipo de entrada, existen dos tipos de entrada, por línea de comando (línea por línea) y por archivo (todo un código fuente). Esto es programación en Java, por lo cual no entraré mucho en detalle y cabe aclarar que existen más formas de definir los dos tipos de entradas, aquí solo veremos dos básicas, pero si sabes programar en Java puedes colocar tu instrucción favorita para definir el tipo de entrada.

JavaCC espera a que el usuario escriba el código de acuerdo a la gramática llamada y a los tokens aceptados por ésta. Cuando encuentra un delimitador ejecuta la acción programada en la gramática.

Este tipo de entrada se obtiene con la instrucción System.in de esta forma si ustedes colocan la siguiente línea, podrán leer una línea:

/*****************************************************
  Lenguaje Liza Ideado por Rapt para fines educativos.
  En este ejemplo solo vemos instrucciones de entrada
  y salida.

  Este ejemplo nos muestra la entrada por linea de
  comando.
*****************************************************/

PARSER_BEGIN(Liza)
 public class Liza{
  public static void main(String arg[])throws ParseException {
   Liza parser = new Liza(System.in);
   System.out.println("Sentencia:");
   System.out.println(parser.Programa());
  }
 }
PARSER_END(Liza)

SKIP:
{
 <"\t"|" "|"\n"|"\r">
}

TOKEN:
{
  <LEE:"lee">
 |<PON:"pon">
 |<PNT: ".">
 |<ID: (["a"-"z"]|["0"-"9"]|"_")*>
 |<CAD: "\""(~["\n","\r"])*"\"">
}

void Lee():{}
{
 <lee><id><pnt>
}

void Pon():{}
{
 <pon>(<id>|<cad>)<pnt>
}

String Programa():{}
{
 (Lee()|Pon())
  {
   return "Es una instruccion aceptada";
  }
}

Este pequeño programa espera que el usuario coloque las instrucciones <lee id.> o <pon id.> o <pon "cadena".> de otro modo mandará un error.

Este tipo de entrada es la más utilizada por los compiladores, pues se lee un código fuente (archivo) y se intenta compilar, las líneas para lograrlo son las siguientes:

Aquí primero se declara la instancia de nuestra clase de JavaCC, luego intentamos leer un archivo, donde Archivo es una cadena de caracteres que indican la ruta (si es necesaria) y el nombre del archivo. Si no logra leer el archivo nos arroja el FileNotFoundException, pero detallar solo sería entrar a Java, así que sólo les diré que en esa parte pueden mandar un mensaje de que no se encontró el archivo. A continuación colocó el mismo programa del ejemplo anterior, sólo que con las modificaciones necesarias para leer el código desde un archivo.

/*****************************************************
  Lenguaje Liza Ideado por Rapt para fines educativos.
  En este ejemplo solo vemos instrucciones de entrada
  y salida.

  Este ejemplo nos muestra la entrada por archivo
*****************************************************/

PARSER_BEGIN(Liza)
import java.io.*;
 public class Liza{
  public static void main(String arg[])throws ParseException {
   BufferedReader Nuevo= new BufferedReader(new InputStreamReader(System.in));
   String Cadena;
   Liza parser;
   System.out.print("Ruta y Nombre del archivo: ");
   try{
    Cadena=Nuevo.readLine();
   }catch(IOException e){
   	System.out.println("Error al leer la cadena");
   	return;
   }
   try{
    parser = new Liza(new FileInputStream(Cadena));
   }catch(FileNotFoundException e){
   	System.out.println("El archivo "+Cadena+" no se encuentra");
   	return;
   }
   while(parser.Programa());
  }
 }
PARSER_END(Liza)

SKIP:
{
 <"\t"|" "|"\n"|"\r">
}

TOKEN:
{
  <LEE:"lee">
 |<PON:"pon">
 |<PNT: ".">
 |<ID: (["a"-"z"]|["0"-"9"]|"_")*>
 |<CAD: "\""(~["\n","\r"])*"\"">
}

void Lee():{}
{
 <LEE><ID><PNT>
}

void Pon():{}
{
 <PON>(<ID>|<CAD>)<PNT>
}

boolean Programa():{}
{
 (Lee()|Pon())
  {
   System.out.println("Es una instruccion aceptada");
   return true;
  }
 |<EOF>
  {
   System.out.println("Codigo analizado exitosamente");
   return false;
  }
}

Espero que les haya quedado clara la definición del programa, por último veremos un ejemplo de cómo jalar una clase de JavaCC, sin necesidad de que el main sea declarado en JavaCC, para esto utilizaremos el mismo main, pero en otro archivo, al que llamaremos afuera.java. Vemos a nuestra derecha el archivo de JavaCC (*.jj) y a la izquierda el archivo afuera.java.

/*****************************************************
  Lenguaje Liza Ideado por Rapt para fines educativos.
  En este ejemplo solo vemos instrucciones de entrada
  y salida.

  Este ejemplo nos muestra como poner el main
 en otro archivo.
*****************************************************/

PARSER_BEGIN(Liza)
import java.io.*;
 public class Liza{
 }
PARSER_END(Liza)

SKIP:
{
 <"\t"|" "|"\n"|"\r">
}

TOKEN:
{
  <LEE:"lee">
 |<PON:"pon">
 |<PNT: ".">
 |<ID: (["a"-"z"]|["0"-"9"]|"_")*>
 |<CAD: "\""(~["\n","\r"])*"\"">
}

void Lee():{}
{
 <lee><id><pnt>
}

void Pon():{}
{
 <pon>(<id>|<cad>)<pnt>
}

boolean Programa():{}
{
 (Lee()|Pon())
  {
   System.out.println("Es una instruccion aceptada");
   return true;
  }
 |<eof>
  {
   System.out.println("Codigo analizado exitosamente");
   return false;
  }
}

/*****************************************************
  Archivo afuera.java nos muestra el uso de una
  clase JavaCC sin necesidad del main en el mismo
  archivo de JavaCC

  Este ejemplo nos muestra como poner el main
 en otro archivo.
*****************************************************/
import java.io.*;
class afuera {
 afuera(){}	 
 public static void main(String arg[])throws ParseException {
   BufferedReader Nuevo= new BufferedReader(new InputStreamReader(System.in));
   String Cadena;
   Liza parser;
   System.out.println("Esta en afuera.java :D");
   System.out.print("Ruta y Nombre del archivo: ");
   try{
    Cadena=Nuevo.readLine();
   }catch(IOException e){
   	System.out.println("Error al leer la cadena");
   	return;
   }
   try{
    parser = new Liza(new FileInputStream(Cadena));
   }catch(FileNotFoundException e){
   	System.out.println("El archivo "+Cadena+" no se encuentra");
   	return;
   }
   while(parser.Programa());
  }
}

Cabe aclarar que los archivos están dentro del mismo proyecto (sin importar el ide que se utilice) y que el proyecto lleva el nombre de afuera. Ya para finalizar, les explicaré cómo compilar los archivos de JavaCC.

Para nuestro ejemplo utilizaré el IDE de Java JCreator LE de Wendel de Witte, bájalo de su página oficial http://www.jcreator.com.

Primero abrimos el javaccw.exe, que se encuentra en el directorio bin de javacc2.1, ahí eliges el archivo [fig. 1], detallas las opciones de JavaCC [fig. 2] (no te metas en esto, si tu conocimiento sobre JavaCC no excede del mío ^_^U o al menos que te guste experimentar). Luego confirmamos presionando el botón build [fig. 3] y por último nos saldrán los mensjes de errores o en su defecto el maravilloso Parser generated successfully [fig. 4].

Ya creado los archivos, nos metemos a nuestro IDE y creamos un proyecto con el mismo nombre que la clase que contiene el main para que el proyecto lo reconozca como la clase principal [fig. 5]. Luego colocamos nuestros archivos dentro del proyecto [fig. 6], después compilamos [fig. 7] y por último corremos el programa [fig. 8].

fig. 6: Para insertar todos los archivos solo se le da click derecho sobre
el nombre del proyecto realzado en azul y se escoje agregar arhivos.