INTEGRANTES:

HUASACCA HUARACA ,AYDER

08200103
AGUILAR QUISPE ,JAIME
10200072
SILVESTRE SERRANO ,JOHN PETER
08200061

UNMSM-FISI2013

Ao de la Inversin para el Desarrollo Rural y la

Seguridad Alimentaria

APLICACIN EN JAVACC
CONSIDERACIONES A TENER EN CUENTA PARA LA ELABORACION DEL
PROYECTO:
El software utilizado:
javacc-5.0
jdk(JAVA)
Los Archivos utilizados son:
TokenAsignaciones.java
Proyecto.jj
ejemplo.txt
ejemplo2.txt
LA EJECUCION DEL PROYECTO:
Se realizara a traves de la consola de Windows
TokenAsignaciones:
Es una clase que actuara como tabla de smbolos y Analizador Semntico a
travs de 2 rutinas Semnticas.
Esta clase ser utilizada en el archivo proyecto.jj .
Atributos:
Hashtable tabla : Tabla que almacenara los tokens declarados
Listas que guardaran los tipos compatibles de las variables:
ArrayList<Integer> intComp
ArrayList<Integer> decComp
ArrayList<Integer> strComp
ArrayList<Integer> chrComp
Metodos:
InsertarSimbolo(Token identificador, int tipo) :
En este metodo se agrega a la tabla de tokens el identificador que esta
siendo declarado junto con su tipo de dato
SetTables()
En este metodo se inicializan las tablas, las cuales almacenaran los tipo de
datos compatibles
Rutinas Semanticas:
checkAsing(Token TokenIzq, Token TokenAsig):
Valida que la Asignacion entre tipos de Datos sea la correcta.

Ejemplo (int a; a=3.1416 Esta asignacin esta mal)

checkVariable(Token checkTok)
Metodo que verifica si un identificador ha sido declarado

INTRODUCCION
La herramienta que vamos a usar para definir nuestro lenguaje, y por
consiguiente su intrprete, va a ser el metacompilador JavaCC.
Un metacompilador o generador de parsers es una herramienta que, a partir de
la especificacin de un lenguaje, construye un programa o analizador que es
capaz de reconocer secuencias o elementos de dicho lenguaje. En general, la
especificacin del lenguaje abarca tanto el aspecto lxico como el sintctico, y

son los que permiten la construccin del parser, mientras que el aspecto
semntico del lenguaje.
Para culminar el trabajo asignado por el profesor tenemos que saber unas
pequeas definiciones:

Un editor de texto.
Un compilador.
Un intrprete.
Un depurador.
Un cliente.
Posibilidad de ofrecer un sistema de control de versiones.
Factibilidad para ayuda en la construccin de interfaces grficas de
usuario.

ACTIVIDADES A DESARROLLAR
Cuando nos enfrentamos a un problema de procesar una expresin debemos
tener en cuenta primeramente dos cosas: cul es su lxico (las palabras que lo
forman) y su sintaxis (las reglas que definen el orden del lxico).

AL desarrollar el trabajo definamos el cdigo fuente de nuestro compilador,

cuya misin ser interpretar una expresin de nuestro lenguaje de la mejor de
las formas y devolver un objeto segn los criterios de la expresin. El
compilador est dividido en varias partes:
TOKEN.-Describe los componentes lxicos (tokens) en la gramtica. Ah estn
la forma de los identificadores, los operadores lgicos, los operadores
aritmticos, los separadores, etc. Bsicamente son una forma de expresiones
regulares para definir cada uno de ellos.
PARSER_BEGIN y PARSE_END.-Entre estas lneas de cdigo va encerrado la
unidad de compilacin de java.
SKIP.- Son simplemente ignoradas por el manejador de tokens (Analizador
lxico). Aqu van descritos los espacios en blanco, las tabulaciones, los saltos
de
lnea
etc.
Mtodos VOID.-define el nombre de nuestro analizador e incluye mtodos de
utilidad (en cdigo Java) que ser incluidos en el analizador sintctico sin
modificar y que podremos usar desde las acciones sintcticas.

GRAMATICA UTILIZADA EN EL
PROYECTO
<imprimir> <listaI>
<listaI> imprime ID <bloqueI> ; <listaI>

<comparacion> (ID | <valor>) <operadorLogico> (ID | <valor>)
<operadorLogico> < | > | <= | >= | <> | ==
<valor> <numero> | <decimal>
<numero> <digito>
<digito> <numero>
<digito>0|1|2|3|4|5|6|7|8|9
<decimal> <numero> . <numero>
<ID> <letra><resto>
<letra> a | b | c | |z
<resto> <letra><resto>
<digito><resto>

<lenguaje> <declVariables><listaSentencias>
<declVariables> <listaDecl>
<listaDecl> <dec>;<listaDecl>

<dec> <tipo><listaVar>
<listaVar> <ID><resto>
<resto> , <ID><resto>

<tipo> entero | real

<listaSentencias><asignacion> | <if> | <while> | <leer>
<asignacion> <listaAsig>
<listaAsig> <Asig>;<listaAsig>

<Asig> <ID> = (<valor> | ID) <demas>

<demas> <operadorM> <valor> | ID <demas>

<operadorM> + | - | * | /
<if> si(<comp>)<bloque>fsi
<bloque> <bloqueV><bloqueF>
<bloqueV> <listaSentencias>
<bloqueF> sino <moduloF>

<moduloF> <listaSentencias>
<while><mientras> (<comparacion>) <bloqueR> fmientras
<bloqueR> <listaSentencias>
<leer><listaLeer>
<listaLeer>leer<ID><bloqueL>;<listaLeer>

Implementacin con JavaCC

(proyecto.jj)
PARSER_BEGIN(proyecto)
import java.io.*;
class proyecto
{
public static void main( String[] args )throws ParseException, Exception
{
try
{
proyecto analizador = new proyecto( System.in ) ;
analizador.Programa();
System.out.println("\tAnalizador ha terminado el analisis.");
}
catch(ParseException e)
{
System.out.println(e.getMessage());
System.out.println("\tAnalizador ha terminado el analisis con
Errores.");
}
}
}
PARSER_END(proyecto)

TOKEN :

{
<ASIGNACION : "=">
| <SUMA : "+" >
| <RESTA:"-">
| <MULTIPLICACION:"*">
| <DIVISION:"/">
| <INCREMENTO: "++" >
| <DECREMENTO: "--" >

}
TOKEN:
{

<PROGRAMA: "Programa" >

| <IF: "si" >
| <ELSE:"sino" >
| <FIF:"fsi" >
| <WHILE:"mientras" >
| <FWHILE:"fmientras" >
| <WRITE:"escribir" >
| <READ:"leer" >
}
TOKEN:
{
<LPAREN: "(" >
| <RPAREN: ")" >
| <LBRACE: "{" >

| <RBRACE: "}" >

| <LBRACKET: "[" >
| <RBRACKET: "]" >
| <PTOCOMA: ";" >
| <COMA: "," >
| <DOT: "." >
| <DOUBLECOMMA: "\"">
}
TOKEN:
{
<EQ: "==" >
| <LE: "<=" >
| <MN: "<" >
| <GE: ">=" >
| <GR: ">" >
| <NE: "!=" >
| <OR: "||" >
| <AND: "&&">
}

TOKEN:
{
<INT:"entero"> //44--ala eliminar algunos tokens se altera el numero
| <DEC: "real"> //45
| <CHR: "caracter"> //46
| <STR: "cadena"> //47
| <NUMBER : (["0"-"9"])+> //48

| <ID : ["a"-"z","A"-"Z"](["a"-"z","A"-"Z","0"-"9","_"])*> //49

| <DECIMAL : (["0"-"9"])+["."](["0"-"9"])+ > //50
| <CADENA : <DOUBLECOMMA>["a"-"z","A"-"Z","0"-"9"," "](["a"-"z","A"-"Z","0"-"9","
",":",";","."])*<DOUBLECOMMA>> //51
| <CARAC : "'"["a"-"z","A"-"Z","0"-"9"]"'" >//52
| <DOUBLEPOINT : ":">
}

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

void Programa() :
{}
{
<PROGRAMA><ID>Principal()<EOF>
}

void Principal():
{
TokenAsignaciones.SetTables();
}
{

<LBRACE>Sentencias()<RBRACE>
}

void VariablesLocales():
{
int td;
Token var;
}
{
(
(TiposDatos())
{
td = token.kind;
}
var = <ID>
{
TokenAsignaciones.InsertarSimbolo(var, td);
}
[VariablesAsignacion(var)]
(
<COMA>
var = <ID>
{
TokenAsignaciones.InsertarSimbolo(var, td);
}
[VariablesAsignacion(var)]
)*
<PTOCOMA>

)
(VS())
}

void VariablesAsignacion(Token v1):

{
Token v2;
Token v3;
String res;
boolean imp = false;
}
{
<ASIGNACION>
(TiposAsignaciones())
{
v2 = token;
res = TokenAsignaciones.checkAsing(v1, v2);

if(res != " ")

{
System.out.println(res);
imp = true;
}
}
(OpAritmetico()
TiposAsignaciones()
{

v3 = token;
res = TokenAsignaciones.checkAsing(v1, v3);

if(res != " " && !imp)

{
System.out.println(res);
}
})*
}

void VS():
{}
{
LOOKAHEAD(3)VariablesLocales() | Sentencias()
}

void Sentencias():
{}
{
(
VariablesLocales()
| SentenciaIf()
//| SentenciaFor()
| SentenciaWhile()
|
LOOKAHEAD(2)SentenciaAsignacion()<PTOCOMA>{TokenAsignaciones.segunda = 0;}
| SentenciaWrite()

| SentenciaRead()<PTOCOMA>
//| SentenciaSwitch()
)*
}

//Sentencia IF
void SentenciaIf():
{}
{
<IF><LPAREN> A() <RPAREN>Sentencias()(Sino())*
}
void Sino():
{}
{
<ELSE> Sentencias()|<FIF>
}

void A():
{}
{
Comparaciones() ([(<AND>|<OR>)] Comparaciones())*
}
//Fin sentencia if

void Comparaciones():
{}
{

Valor()Operadores()Valor()
}
void Valor():
{}
{
LOOKAHEAD(2) (<ID> | <NUMBER>) | Expresion()
}
void Expresion():
{}
{
LOOKAHEAD(2)(<NUMBER> | <ID>)
|(<ID>|<NUMBER>) OpAritmetico() (<ID>|<NUMBER>)
}

void Operadores():
{}
{
<EQ>
| <LE>
| <GE>
| <NE>
| <GR>
| <MN>
}
int OpAritmetico():
{}
{

(<SUMA> {return 1;})

| (<RESTA> {return 1;})
| (<MULTIPLICACION> {return 1;})
| (<DIVISION> {return 1;})
| ({return 0;})

{return 0;}
}

void TiposDatos():
{}
{
<INT>
|<DEC>
|<STR>
|<CHR>
}

void DeclaracionUnaVariable():
{
int td;
Token var;
}
{
(TiposDatos())

{
td = token.kind;
}
var = <ID>
{
TokenAsignaciones.InsertarSimbolo(var, td);
}
[VariablesAsignacion(var)]
}

//Sentencia while

void SentenciaWhile():
{}
{
<WHILE> <LPAREN> Comparaciones() <RPAREN> Sentencias() <FWHILE>
}

//Sentencia ASIGNACION
void SentenciaAsignacion():
{
Token v1;
Token v2;
Token v3;
int aux;
String res;
boolean imp = false;

}
{
v1 = <ID>
(<ASIGNACION>
(TiposAsignaciones())
{
v2 = token;
res = TokenAsignaciones.checkAsing(v1, v2);

if(res != " ")

{
System.out.println(res);
imp = true;
}
}
(LOOKAHEAD(2)OpAritmetico()
TiposAsignaciones()
{
v3 = token;
res = TokenAsignaciones.checkAsing(v1, v3);

if(res != " " && !imp)

{
System.out.println(res);
}
})*
|

(<INCREMENTO>|<DECREMENTO>)
{
res = TokenAsignaciones.checkVariable(v1);

if(res != " ")

System.out.println(res);
})

}
void TiposAsignaciones():
{}
{
<ID>
| <NUMBER>
| <DECIMAL>
| <CADENA>
| <CARAC>
}

//Sentencia WRITE
void SentenciaWrite():
{}
{
<WRITE> <LPAREN> (Expresion()(<SUMA><CADENA>)*|
<CADENA>(<SUMA>Expresion())*)* <RPAREN> <PTOCOMA>
}

//Sentencia READ
void SentenciaRead():
{}
{
<READ><LPAREN><RPAREN>
}

PRODUCCION
El proyecto se ubica en la direccin:
en la imagen

C:\p Con los archivos que se muestran

Aqu compilamos el archivo proyecto.jj

Aqu compilamos los archivos *.java creados por el compilador javacc.

RESULTADOS DE LA EJECUCION CON LOS CODIGOS DE PRUEBA:

Aqu ejecuto el proyecto con el archivo ejemplo.txt que contiene un codigo
correcto .

Aqu ejecuto el proyecto con el archivo ejemplo2.txt que contiene un codigo

Errado y por consiguiente mostrara Error en lnea 13 .