import java.io.

*;
import java.util.*;
import javax.swing.*;
public class LexicoSintactico extends JFrame
{
static String [] reservadas={"RE","WR","MAIN","SI","SINO"};//PALABRAS RE
SERVADAS
static Vector <Character> micodigo=new Vector<Character>();//vector fuen
te
static Vector <token> parser=new Vector <token> ();//vector con los toke
ns clasificados
String ident[][]=new String [50][2];
static token tkn;
int ptr,ptr2=0,linea=0;
char ch, sig;
//-----------------------------------------Anilizador Lexico--------------------
---------------------------------------------
public void clasificaTokens()
{
while(true)
{ if(ptr==micodigo.size())
{ break;
}
ch=micodigo.elementAt(ptr);
sig=micodigo.elementAt(ptr+1);
if(ch==' ' || (int)ch==9 || (int)ch==10 || (int)ch==11 || (int)ch==1
3 || (int)ch==95)//codigo ascii
{ ptr++;
}
else
{ //letras A-Z || a-z
if((int)ch>=65 && (int)ch<=90 || (int)ch>=97 && (int)ch<
=122)//codigo ascii
{ obtenerPalabra();
}
else
{ //digitos 0-9
if((int)ch>=48 && (int)ch<=57)
{ obtenerEntero();
}
else
{ if(Simbolo(ch,sig)==true)
{ ptr++;
}
}
}
if(ptr==micodigo.size()-1)//si se llego al final del
vector salir
{ break;
}
}
//System.out.println(parser.lastElement());
}
}//termina clasifica tokens
//VARIABLES A-Z || a-z
public void obtenerPalabra()
 { String tok="";
while(true)
{ char car=micodigo.elementAt(ptr);
//letras A-Z || a-z
if((int)car>=65 && (int)car<=90 || (int)car>=97 && (int)
car<=122)//codigo ascii
{ tok+=car;
ptr++;
}
else
{ if(buscaReservadas(tok,reservadas)==true)
{ token nuevo=new token(tok,"Reservada");
parser.add(nuevo);
break;
}
else
{
token nuevo=new token(tok,"Identificador
");
parser.add(nuevo);
break;
}
}
}
if(ptr==micodigo.size()-1)//si se llego al final del vector fuen
te
{ if(buscaReservadas(tok,reservadas)==true)
{ token nuevo=new token(tok,"Reservada");
parser.add(nuevo);
return;
}
else
{ token nuevo=new token(tok,"Identificador");
parser.add(nuevo);
return;
}
}
}//obtiene palabra y termina
public boolean buscaReservadas(String palabra,String []arreglo)
{ for (int i=0;i<arreglo.length;i++)
{ if(palabra.equals(arreglo[i]))
{ return true;
}
}
return false;
} //termina busca reservadas
//CONSTANTES NUMERICAS ENTERAS
public void obtenerEntero()
{ String numero="";
while(true)
{ char num=micodigo.elementAt(ptr);
if((int)num>=48 && (int)num<=57)
{ numero+=num;
ptr++;
}
 else
{ token nuevo=new token(numero,"Entero");
parser.add(nuevo);
return;
}
if(ptr==micodigo.size()-1)//si se llego al final del vec
tor fuente
{ token nuevo=new token(numero,"Entero");
parser.add(nuevo);
return;
}
}
}//obtener entero termina
//OPERADORES
public boolean Simbolo(char ch,char sig)
{ token nuevo;
switch(ch)
{ case '=': if(sig=='=')
{ ptr++;
nuevo=new token("==","co
mparacion");
parser.add(nuevo);
return true;
}
else
{ nuevo=new token("=","asi
gnacion");
parser.add(nuevo);
return true;
}
case '+': nuevo=new token("+","oper");
parser.add(nuevo);
return true;
case '-': nuevo=new token("-","oper");
parser.add(nuevo);
return true;
case '*': nuevo=new token("*","oper");
parser.add(nuevo);
return true;
case '/': nuevo=new token("/","oper");
parser.add(nuevo);
return true;
case '(': nuevo=new token("(","par_izq")
;
parser.add(nuevo);
return true;
case ')': nuevo=new token(")","par_der");
parser.add(nuevo);
return true;
case '{': nuevo=new token("{","llave_izq");
parser.add(nuevo);
return true;
case '}': nuevo=new token("}","llave_der");
parser.add(nuevo);
 return true;
case '%': nuevo=new token("%","modulo");
parser.add(nuevo);
return true;
case ';': nuevo=new token(";","punto_coma");
parser.add(nuevo);
return true;
}
return false;
}
//----------------------------------------------------Implementacion de la grama
tica---------------------------------
//metodo para obtener el siguiente token del vector parser
public void getToken()
{ tkn = parser.elementAt(ptr2);
System.out.println(tkn.getInfo());
ptr2++;
}
public boolean codigo()
{ if( tkn.getInfo().equals("RE") )
{ return listaInstr();
}
else
{ return false; }
}
//checa el codigo
public boolean listaInstr()
{ if( instr() )
{ if( tkn.getInfo().equals(";") || tkn.getInfo().equals("}") )
{ getToken();
if(tkn.getInfo().equals("}"))
{ return true;
}
else
return listaInstr();
}
else
{ errores(6);
return false;
}
}
else
{ errores(9);
return false;
}
}
//revisa tipo de instruccion
public boolean instr()
{ if( tkn.getInfo().equals("RE") )
{ getToken();
return lectura();
}
else if( tkn.getInfo().equals("WR") )
{ getToken();
return escritura();
}
else if( tkn.getTipo().equals("Identificador") )
{ getToken();
return asignacion();
 }
else if( tkn.getInfo().equals("SI") )
{ getToken();
return si();
}
else if( tkn.getInfo().equals("SINO") )
{ getToken();
return si();
}
else
{ return false; }
}
//lectura de variables
public boolean lectura()
{ if( tkn.getTipo().equals("Identificador") )
{ getToken();
if(tkn.getInfo().equals(","))
{ getToken();
return lectura();
}
else
return true;
}
else
{ errores(5);
return false;
}
}
//escritura en pantalla
public boolean escritura()
{ if( tkn.getTipo().equals("Identificador") )
{ getToken();
if(tkn.getInfo().equals(","))
{ getToken();
return escritura();
}
else
return true;
}
else
{ errores(5);
return false;
}
}

public boolean asignacion()

{ if( tkn.getInfo().equals("=") )
{ getToken();
return operaciones();
}
else
{ errores(7);
return false;
}
}
public boolean operaciones()
{ if( tkn.getInfo().equals("(") )
{ getToken();
if( operaciones() )
{ if( tkn.getInfo().equals(")") )
 { getToken();
if( tkn.getTipo().equals("oper") )
{ getToken();
return operaciones();
}
return true;
}
else
{ errores(8);
return false;
}
}
else
{
return true;
}
}
else
{ return operacion();
}
}
public boolean operacion()
{ if( tkn.getTipo().equals("Identificador") || tkn.getTipo().equals("Enter
o") )
{ getToken();
if(tkn.getTipo().equals("oper"))
{ getToken();
return operaciones();
}
else
{ return true;
}
}
else
return true;
}
//selectiva
public boolean si()
{ if(tkn.getInfo().equals("("))
{ getToken();
if( condicion() )
{ getToken();
if( tkn.getInfo().equals(")") )
{ getToken();
if( tkn.getInfo().equals("{") )
{ getToken();
if( listaInstr() )
{ if(tkn.getInfo().equals("}"))
{ getToken();
if( tkn.getInfo().equals
("SINO") )
{ getToken();
if( tkn.getInfo(
).equals("{") )
{ getToken
();
if( list
aInstr() )
{
if(tkn.getInfo().equals("}"))
{ return true;
}
else
{ errores(4);
return false;
}
}
else
{
return false;
}
}
else
{ errores(
2);
return f
alse;
}
}
else
{ return true;
}
}
else
{ errores(4);
return false;
}
}
else
{ return false;
}
}
else
{ errores(2);
return false;
}
}
else
{ errores(8);
return false;
}
}
else
return false;
}
else
{ errores(10);
return false;
}
}
public boolean condicion()
{
if( tkn.getTipo().equals("Identificador") || tkn.getTipo().equals("Enter
o") )
 { getToken();
if( tkn.getInfo().equals("==") )
{ getToken();
if( tkn.getTipo().equals("Identificador") || tkn.getTipo
().equals("Entero") )
{ return true;
}
else
{ errores(11);
return false;
}
}
else
{ errores(12);
return false;
}
}
else
{ errores(11);
return false;
}
}
//errores
public void errores(int e)
{ String error="";
switch(e)
{ case 1: error="\nERROR 1 : Falta la palabra reservada MAIN";
break;
case 2: error="\nERROR 2 : Falta inicio de bloque '{'";
break;
case 3: error="\nERROR 3 : Anomalia en la Lectura de variables";
break;
case 4: error="\nERROR 4 : Falta fin de bloque '}'";
break;
case 5: error="\nERROR 5 : Falta un Identificador";
break;
case 6: error="\nERROR 6 : Falta terminador de sentencia ';'";
break;
case 7: error="\nERROR 7 : Falta operador de asignacion '='";
break;
case 8: error="\nERROR 8 : Falta parentesis de cierre ')'";
break;
case 9: error="\nERROR 9 : Falta Instruccion correcta";
break;
case 10:error="\nERROR 10 : Falta parentesis de apertura '('";
break;
case 11:error="\nERROR 11 : Falta Identificador o Constante Ente
ra";
break;
case 12:error="\nERROR 12 : Falta un operador de Comparacion";
}
System.out.println(error);
}
public static void imprimeparser()
{
for(int x=0;x<parser.size();x++)
{
System.out.println(parser.elementAt(x).info+""+parser.el
ementAt(x).tipo);
}
 }
//-----------------------------------------------Carga Archivo------------------
---------------------------------------------
public void cargaFuente()
{
BufferedReader LeeArchivo;
JFileChooser selectorArchivo = new JFileChooser();
selectorArchivo.setFileSelectionMode( JFileChooser.FILES_ONLY );
int resultado = selectorArchivo.showOpenDialog( this );
if ( resultado == JFileChooser.CANCEL_OPTION )
return;
// obtener el archivo
File nombreArchivo = selectorArchivo.getSelectedFile();
if ( nombreArchivo == null || nombreArchivo.getName().equals( ""
) )
JOptionPane.showMessageDialog( this, "Nombre de archivo incorrec
to",
"Nombre de archivo incorrecto", JOptionPane.ERROR_MESSAG
E );
else
{ // abre el archivo
try
{
LeeArchivo = new BufferedReader(new FileReader( nombreAr
chivo ) );
int i=0,j=0;
while (i!=-1)
{
i=LeeArchivo.read();
micodigo.add(new Character((char)i));
System.out.println("" + micodigo.elementAt(j++) );
}
System.out.println("\n=¡¡Cargado Exitosamente!!\n\n");
JOptionPane.showMessageDialog( this, "¡¡Cargado Exitosamente!!",
"Cargando", JOptionPane.INFORMATION_MESSAGE );
}
catch ( IOException excepcionES )
{
JOptionPane.showMessageDialog( this, "Error al a
brir el archivo", "Error", JOptionPane.ERROR_MESSAGE );
}
}
}//-----------------------------------------------------------Carga Fuen
te----------------------------------------
//----------------------------------------MAIN-------------------------------
-----------------------------------------------
public static void main (String[] args)
{
LexicoSintactico lexsin= new LexicoSintactico();
lexsin.cargaFuente(); //Carga el archivo fuente
lexsin.clasificaTokens();//Llama al metodo que identifica los to
kens cargados de la fuente
lexsin.imprimeparser();//Llama al metodo que imprime los tokens
del scaner
 lexsin.main_codigo();Llama al metodo que realiza el analizis de
sintaxis del codigo de acuerdo a los tokens obtenidos en el Análisis Léxico
System.exit(0);
}//-------------------------------------------- MAIN -----------------------
------------------------------------------------
public void main_codigo()
{ try
{ int i=0;
getToken();
if(tkn.getInfo().equals("MAIN"))
{ getToken();
if(tkn.getInfo().equals("{"))
{ getToken();
if(codigo())
{ if(tkn.getInfo().equals("}"))
{
JOptionPane.showMessageDialog( this,"Compilación Completa...\nSintaxis Correcta","P
arser",JOptionPane.INFORMATION_MESSAGE );
}
else
{ errores(4); }
}
else
{ errores(3); }
}
else
{ errores(2); }
}
else
errores(1);
}
catch(Exception e)
{ JOptionPane.showMessageDialog(this,"Error al Compilar","Error",
JOptionPane.ERROR_MESSAGE);
}
}
}