INSTITUTO TECNOLOGICO DE

TLAXIACO

LENGUAJES Y AUTOMATAS I
ANALIZADOR LEXICO
(HERRAMIENTA JFLEX)

ASESOR: ING. JOSE ALFREDO ROMAN CRUZ
INTEGRANTES DEL EQUIPO:
ABAD SILVA GARCIA
DOROTEO LPEZ BAUTISTA
IVAN SOSA MARTINEZ
JESUS FERIA ORTIZ

GRUPO: U SEXTO SEMESTRE


FECHA DE ENTREGA:
HEROICA CIUDAD DE TLAXIACO A 26/06/2014.




CODIGO MODIFICADO INTERFAZ

public void probarLexerFile() throws IOException{
int contIDs=0;
tokenslist = new LinkedList<identificador>();
File fichero = new File ("fichero.txt");
PrintWriter writer;
try {
writer = new PrintWriter(fichero);
writer.print(jTextField1.getText());
writer.close();
} catch (FileNotFoundException ex) {
Logger.getLogger(interfaz.class.getName()).log(Level.SEVERE, null, ex);
}
Reader reader = new BufferedReader(new FileReader("fichero.txt"));
Lexer lexer = new Lexer (reader);
String resultado="";
while (true){
Token token =lexer.yylex();
if (token == null){
for(int i=0;i<tokenslist.size();i++){
System.out.println(tokenslist.get(i).nombre + "=" + tokenslist.get(i).ID);
}
jTextField2.setText(resultado);
return;
}
switch (token){
case SUMA:
resultado=resultado+ "< OPERADOR DE SUMA>";
break;
case RESTA:
resultado=resultado+ "< OPERADOR DE RESTA >";
break;
case MULT:
resultado=resultado+ "< OPERADOR DE MULTIPLICACION >";
break;
case DIV:
resultado=resultado+ "< OPERADOR DIFERENTE >";
break;
case ASSIGN:
resultado=resultado+ "< OPERADOR IGUAL>";
break;
case MAYOR_IGUAL:
resultado=resultado+ "< >= >";
break;
case MENOR_IGUAL:
resultado=resultado+ "< <= >";
break;
case DIFERENTE:
resultado=resultado+ "< != >";
break;
case MAYOR:
resultado=resultado+ "< > >";
break;
case MENOR:
resultado=resultado+ "< < >";
break;
case INT:
resultado=resultado+ "< " + lexer.lexeme + " NUMERO ENTERO>";
break;
case NUMERO_REAL:
resultado=resultado+ "< " + lexer.lexeme + " NUMERO REAL ";
break;
case NOTACION_CIENTIFICA:
resultado=resultado+ "< " + lexer.lexeme + " NOTACION CIENTIFICA ";
break;
case ERROR:
resultado=resultado+ "Error, simbolo no reconocido ";
break;
case ID: {
contIDs++;
identificador tokenitem=new identificador();
tokenitem.nombre=lexer.lexeme;
tokenitem.ID=contIDs;
tokenslist.add(tokenitem);
resultado=resultado+ "<ID" + contIDs + "> ";
break;
}

default:
resultado=resultado+ "<"+ lexer.lexeme + "> ";
}
}
}









CODIGO MODIFICADO LEXER.FLEX
package analizador;
import static analizador.Token.*;
%%
%class Lexer
%type Token
L = [a-zA-Z_]
D = [0-9]
R = [+|-]
D2=[.]
N=[E|e]
WHITE=[ \t\r\n]
%{
public String lexeme;
%}
%%
{WHITE} {/*Ignore*/}
"=" {return ASSIGN;}
"+" {return SUMA;}
"*" {return MULT;}
"-" {return RESTA;}
"/" {return DIV;}
"<" {return MENOR;}
">" {return MAYOR;}
"<="{return MENOR_IGUAL;}
">="{return MAYOR_IGUAL;}
"!=" {return DIFERENTE;}

{L}({L}|{D})* {lexeme=yytext(); return ID;}
{R}*{D}+{lexeme=yytext(); return INT;}
{R}*({D}{D2}+{D}+){} {lexeme=yytext(); return NUMERO_REAL;}
{R}*{D}+((({D2}{D}+{N})|({D}+{N}))) ({R}{D}+|({D}+)){lexeme=yytext(); return
NOTACION_CIENTIFICA;}
. {return ERROR;}

CODIGO MODIFICADO TOKEN


package analizador;

/**
*
* @author Carlos
*/
public enum Token {
ID, INT, SUMA, RESTA, DIV, MULT, ASSIGN, ERROR,NUMERO_REAL,
MENOR, MAYOR, DIFERENTE,NOTACION_CIENTIFICA, MENOR_IGUAL, MAYOR_IGUAL;
}















CODIGO MODIFICADO DE LEXER.JAVA
java.io.IOException if any I/O-Error occurs
*/
public Token yylex() throws java.io.IOException {
int zzInput;
int zzAction;

// cached fields:
int zzCurrentPosL;
int zzMarkedPosL;
int zzEndReadL = zzEndRead;
char [] zzBufferL = zzBuffer;
char [] zzCMapL = ZZ_CMAP;

int [] zzTransL = ZZ_TRANS;
int [] zzRowMapL = ZZ_ROWMAP;
int [] zzAttrL = ZZ_ATTRIBUTE;

while (true) {
zzMarkedPosL = zzMarkedPos;

zzAction = -1;

zzCurrentPosL = zzCurrentPos = zzStartRead = zzMarkedPosL;

zzState = ZZ_LEXSTATE[zzLexicalState];


zzForAction: {
while (true) {

if (zzCurrentPosL < zzEndReadL)
zzInput = zzBufferL[zzCurrentPosL++];
else if (zzAtEOF) {
zzInput = YYEOF;
break zzForAction;
}
else {
// store back cached positions
zzCurrentPos = zzCurrentPosL;
zzMarkedPos = zzMarkedPosL;
boolean eof = zzRefill();
// get translated positions and possibly new buffer
zzCurrentPosL = zzCurrentPos;
zzMarkedPosL = zzMarkedPos;
zzBufferL = zzBuffer;
zzEndReadL = zzEndRead;
if (eof) {
zzInput = YYEOF;
break zzForAction;
}
else {
zzInput = zzBufferL[zzCurrentPosL++];
}
}
int zzNext = zzTransL[ zzRowMapL[zzState] + zzCMapL[zzInput] ];
if (zzNext == -1) break zzForAction;
zzState = zzNext;

int zzAttributes = zzAttrL[zzState];
if ( (zzAttributes & 1) == 1 ) {
zzAction = zzState;
zzMarkedPosL = zzCurrentPosL;
if ( (zzAttributes & 8) == 8 ) break zzForAction;
}

}
}

// store back cached position
zzMarkedPos = zzMarkedPosL;

switch (zzAction < 0 ? zzAction : ZZ_ACTION[zzAction]) {
case 8:
{ return RESTA;
}
case 23: break;
case 10:
{lexeme=yytext(); return NUMERO_REAL;}
case 24: break;
case 2:
{ lexeme=yytext(); return ID;

}
case 25: break;
case 11:
{ return DIFERENTE;}
case 26: break;
case 1:

{ return ERROR;
}
case 27: break;
case 12:
{ return MENOR;}
case 28: break;
case 9:
{ return DIV;
}
case 29: break;
case 13:
{ return MAYOR;}
case 30: break;
case 7:
{ return MULT;
}

case 31: break;
case 14:
{ return MENOR_IGUAL;}
case 3:
{ lexeme=yytext(); return INT;
}
case 32: break;
case 15:
{ return MAYOR_IGUAL;}
case 37: break;
case 6:
{ return SUMA;
}
case 33: break;
case 16:
{ lexeme=yytext(); return NOTACION_CIENTIFICA;
}
case 35: break;
case 5:
{ return ASSIGN;
}
case 34: break;
case 17: break;
case 4:
{ /*Ignore*/
}

case 18: break;
default:
if (zzInput == YYEOF && zzStartRead == zzCurrentPos) {
zzAtEOF = true;
return null;
}
else {
zzScanError(ZZ_NO_MATCH);
}
}
}
}


}





PRUEBAS