Grammar added for the PESP language

PESP.java

/* PESP.jjt */

PARSER_BEGIN(analizadorPESP)
class analizadorPESP {
	public static void main(String[] args) throws ParseException, TokenMgrError
	{
		try {			
          analizadorPESP ae = new analizadorPESP(System.in); // System.in
          SimpleNode n = ae.Start();
		  n.dump(" ");
		  System.out.println("Parsing Tree built successfully");
		} catch(TokenMgrError e){
	        System.out.println (" === ERROR LEXICO EN TOKEN. === \n");
	        System.out.println (e.getMessage());
	    } catch(ParseException e){
        	System.out.println(" === Error de parseo encontrado en codigo fuente PESP === \n "+e.getMessage());
	    } catch (Exception e) {
	      System.out.println(" === Oops. There was an error building the parsing tree === \n");
	      System.out.println(e.getMessage());
	      e.printStackTrace();
	    }
	
	}
}
PARSER_END(analizadorPESP)


/* DEFINICION DE ESTRUCTURAS */

TOKEN: {
    <PROGRAMA: "clase">{System.out.println("CLASE PRINCIPAL> "+image+"\n");}
    |<FUNCION: "func" >{ System.out.println("\nFUNCION -> "+image+"\n");}
    |<IF:      "si" > { System.out.println("\nDECISION \t-> "+image);}
    |<ELSE:    "sino" > { System.out.println("\nDECISION NEGADO -> "+image);}
    |<WHILE:   "mientras" > {System.out.println("\nCICLO -> "+image);}
    |<RETURN:  "retorna" > {System.out.println("\nDEVUELVE VALOR -> "+image);}
    |<CONST:   "const" > {System.out.println("\nCONSTANTE -> "+image);}
    |<VAR:     "var" > {System.out.println("\nVARIABLE -> "+image);}
}

/* DEFINICION DE AGRUPACIONES */

TOKEN: {
    <PARENIZQ: "(" >{ System.out.println("ABRE GRUPO -> " +image);}
    |<PARENDER: ")">{ System.out.println("CIERRA GRUPO -> " + image);}
    |<LLAVEIZQ: "{">{ System.out.println("\nABRE BLOQUE -> " + image+"\n");}
    |<LLAVEDER: "}">{ System.out.println("\nCIERRA BLOQUE -> " + image+"\n");}
    
}

/* DEFINICION DE ASIGNACION Y COMPARACIONES*/

TOKEN: {
  	<ASIGNACION: "=" >{ System.out.println("ASIGNACION -> "+image);}
    |<MENOR:     "<">{ System.out.println("MENOR QUE -> "+image);}
    |<MAYOR:     ">">{ System.out.println("MAYOR QUE -> "+image);}
    |<NEGACION:  "!=">{ System.out.println("NEGACION -> "+image);}
    |<IGUALDAD:  "==">{ System.out.println("IGUALDAD -> "+image);}
    |<COMA:      ",">{ System.out.println("COMA -> "+image);}
    |<SEMICOLON: ";">{ System.out.println("CIERRE DE SENTENCIA -> " + image+"\n");}
}

/* DEFINICION DE ARITMETICA */

TOKEN: {
	< SUMA : "+" > { System.out.println("SUMA - > "+image);}
	| < RESTA : "-" > { System.out.println("RESTA - > "+image); }
	| < MULTIPLICACION: "*" > { System.out.println("MULTIPLICACION - > "+image); }
	| < DIVISION: "/" > { System.out.println("DIVISION - > "+image ); }
}


/* DEFINICION DE MODIFICADORES */

TOKEN: {
   <READ: "leer" >{ System.out.println("LEER -> "+image);}
  |<PRINT: "imprime" >{ System.out.println("IMPRIMIR -> "+image);}

}

/* DEFINICION DE IDENTIFICADORES */

TOKEN: {
   <INT: "entero" >{ System.out.println("ENTERO -> "+image);}
  |<STRING: "cadena" >{ System.out.println("CADENA -> "+image);}
  |<BOOLEAN: "booleano" > { System.out.println("BOOLEANO - >"+image);}
  |<NUMBER: (["0" - "9"])+>{ System.out.println("NUMERO -> "+image);}
  |<TEXT: "\"" ( ~["\"","\\","\n","\r"] | "\\" ( ["n","t","b","r","f","\\","\'","\""] | ( ["\n","\r"] | "\r\n")))* "\""> {  System.out.println("CADENA DE TEXTO -> "+image);  }
  |<VALBOOL: "true" | "false" | "-1" > { System.out.println("VALOR BOOLEANO - >"+image);}
  |<IDENTIFICADOR: (["a"-"z", "A"-"Z", "0"-"9"])+ >{ System.out.println("IDENTIFICADOR -> "+image);}
}

/* CARACTERES A IGNORAR */

SKIP: { " " |"\t" |"\n" |"\r" | <"//" (~["\n","\r"])* ("\n" | "\r" | "\r\n")> {System.out.println("= COMENTARIO IGNORADO = ");} }


SimpleNode Start() : {}
{
  <PROGRAMA><IDENTIFICADOR>
  <LLAVEIZQ> 
   (
     bloque()
   )* 
  <LLAVEDER><EOF>
  { return jjtThis; }
}


//void boot () : {}
//{
//  /*(
//    <PROGRAMA>|<FUNCION>|<IF>|<ELSE>|<WHILE>|<RETURN>|<PARENIZQ>|<PARENDER>|<LLAVEIZQ>|<LLAVEDER>
//    | <ASIGNACION>|<MENOR>|<MAYOR>|<NEGACION>|<IGUALDAD>|<COMA>|<SEMICOLON>|<SUMA>| <RESTA>
//    | <MULTIPLICACION>|<DIVISION>| <INT>| <STRING>| <BOOLEAN>| <NUMBER>| <TEXT>| <VALBOOL>| <IDENTIFICADOR>
//    | <CONST> | <VAR> | <READ> | <PRINT>
//  )*
//  < EOF >*/
//
//  <PROGRAMA><IDENTIFICADOR>
//  <LLAVEIZQ> 
//   (
//     bloque()
//      
//   )* 
//  <LLAVEDER><EOF>
//}

void bloque(): { }
{
	LOOKAHEAD(3) variablesGlobales() | funcion() | LOOKAHEAD(2) llamarFuncion() | imprimir() | leer()
}

void variablesGlobales():
{}
{
	(<INT>|<STRING>|<BOOLEAN>) <IDENTIFICADOR> (< ASIGNACION >(< NUMBER >| < TEXT > | < VALBOOL >))* (<COMA><IDENTIFICADOR>)* bloque()
}

void funcion(): {}
{
  <FUNCION><IDENTIFICADOR><PARENIZQ>  parametros() <PARENDER > < LLAVEIZQ >sentencias()<LLAVEDER >
}

void parametros(): { } {
	
	  (
	    (< INT >|<STRING >|<BOOLEAN >) (<IDENTIFICADOR>) (<COMA> <IDENTIFICADOR >)* |
	    LOOKAHEAD(2)(< INT >|<STRING >|<BOOLEAN >) (<IDENTIFICADOR>)
	  )*	
}

void sentencias(): { }
{
	(
	    LOOKAHEAD(3) declaraciones()
	  | imprimir()
	  | leer()
	  | estructuraDecision()
	  | estructuraRepetitiva()
      | retornaValor()
      | llamarFuncion()
	)*
}

void declaraciones():{}
{
  (< INT >|<STRING >|<BOOLEAN >) <IDENTIFICADOR> <ASIGNACION> (<TEXT> | <NUMBER> | <VALBOOL>) DR()
//  <INT> <IDENTIFICADOR> <ASIGNACION> <NUMBER>  DR() |
//  <STRING> <IDENTIFICADOR> <ASIGNACION> <TEXT>  DR() |
//  <BOOLEAN> <IDENTIFICADOR> <ASIGNACION> <VALBOOL>  DR()
}

void DR(): { }
{
  LOOKAHEAD(3) declaraciones() | LOOKAHEAD(3) sentencias() | estructuraRepetitiva() | estructuraDecision() | retornaValor() | llamarFuncion() | imprimir() | leer()
}

void estructuraDecision(): { }
{
  < IF ><PARENIZQ > comparaciones() <PARENDER ><LLAVEIZQ> sentencias()<LLAVEDER >
  	(
  	  LOOKAHEAD(2) < ELSE > <LLAVEIZQ> sentencias() <LLAVEDER >
  	)?
}

void estructuraRepetitiva() : { }
{
	< WHILE ><PARENIZQ > comparaciones() < PARENDER ><LLAVEIZQ > sentencias() <LLAVEDER >
}

void retornaValor():{}
{
  <RETURN><IDENTIFICADOR>
}

void comparaciones(): { }
{
  valor() operadores() valor()
}

void valor(): { }
{
  < IDENTIFICADOR > | < NUMBER > | < TEXT > | < BOOLEAN >
}

void operadores(): {}{
  < MENOR > | < MAYOR > | < NEGACION > | < IGUALDAD >
}

void imprimir(): {}{
	<PRINT><IDENTIFICADOR>
}

void leer():{}{
	<READ ><IDENTIFICADOR >
}

void llamarFuncion():{}{
  	< IDENTIFICADOR > <PARENIZQ ><PARENDER >
}