/* * AnalizadorLex.java * Autor: craneodelrey@msn.

com * Este programa lee un ar

chivo de texto y calcula las parejas ordenadas <[Token],[Lexema]> * por medio de
un Autmata Finito Determinista * Lee lnea por lnea devolviendo un arreglo con los
tokens para su manipulacin*/import java.io.*;import java.awt.*;import java.util.*
;public class AnalizadorLex{
public static String arrayTokens [][];
public static int numCar = 0;///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX///Modulo principal///XXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
public static void main(String[] args)throws IOException{
if(
args.length == 0){
System.out.println("No se especifican
ficheros");
}/*
for(int i = 0; i<args.length; i++)
{
contenidoFichero(args[i]);
}*/
contenidoFichero("Test.plo");
}///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX///Modulo Secundario qu
e lee los Ficheros///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
public static void contenidoFichero(Strin
g nombreFichero){
FileReader elFichero;
BufferedRe
ader lector = null;
String linea;
try{
elFichero = new FileReader(nombreFichero);
le
ctor = new BufferedReader(elFichero);
while((linea = lect
or.readLine()) != null){
numCar = linea.length();
///Por cada linea se devueve un arreglo de N fil
as y dos columnas con los tokens enontrados
array
Tokens = separarTokens(linea);
for (int I = 0; I<
arrayTokens.length; I++){
System.out.prin
tln(arrayTokens[I][0] + "
" + arrayTokens[I][1]);
}
System.out.println("");
}
}catch(Exception e){
System.out.
println(e);
}
//Cierre del fichero
try{
if (lector != null){
lector.close();
}
}catch(IOExce
ption e){
}
}///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX///Funcion separarTokens: Devuel
ve un arreglo de Tokens///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
static String [][] separarTokens(Str
ing row){
int N = row.length(); //longitud de la cadena
int i = 0;
//numero de caracter
St
ring nodo = "0";
//estado del automata actual
String wor
d = "";
//palabra o token que se esta formando
char car
= ' ';
//caracter que sera analizado por el automata
int numTokens = 0;
int nT = numTokens;
//como
en java los "Strings" son objetos, necesite de un arreglo temporal para modific
ar
//el tamao del "Array de Strings" original
Strin
g Tokens [][] = new String [numTokens+1][2];
String TokensT[][] =
new String [numTokens+1][2];
while (i<=N){
if (i==N){
//Se supone que estamos un indice de
spues del final de la linea por lo que
//solo se
aade el estado final de automata y que la linea nunca estara vacia
//lo cual es controlado por el modulo en donde se leen los arc
hivos
nodo = nodo + ".0";
i++;
}else{
car =
Character.toUpperCase(row.charAt(i));
nodo = nodo
Siguiente(nodo, car);
}/*
* La siguente parte es para preparar el Arreglo de Strings y aadir un token cuan
do se haya encontrado No es de gran importancia. Si se omitiera y se escribiera
directamente en el archivo que se desea crear aumentaria considerablemente la
velocidad de ejecucion del programa... Por motivos pesonales decidi que la func
ion devolviera un Arreglo con los tokens He tratado lo mas posible de que la fo
rma de programacion sea lo mas parecido a los dos lenguajes que mas practico C+
+ y Visual Basic para que otros puedan implantarlo en dichos lenguajes
Diria

que este es mi primer programa serio en Java pues veran que desconosco algunos m
etodos para manejar correctamente los Strings*/
if (numT
okens !=nT){
///Copio el arreglo original al arre
glo temporal para incrementar en numero de filas
for (int I=0; I<numTokens; I++){
TokensT[
I][0] = (new String(Tokens[I][0]));
Token
sT[I][1] = (new String(Tokens[I][1]));
}
///Se supone que antes ya se aadio un token por lo que se
nesecita de una nueva linea
Tokens = new String [
numTokens+1][2];
nT = numTokens;
///Copio el arreglo temporal al nuevo arreglo original
for (int I=0; I<numTokens; I++){
Tokens[I][0] = (new String(TokensT[I][0]));
Tokens[I][1] = (new String(TokensT[I][1]));
}
TokensT = new String [numTokens+1][2
];
}/** Se iran aadiendo nuevas filas despues de aadir un
token y hasta que se haya llegado al final de la linea, lo cual es controlado
por la primera senencia: if (i==N){ *//// E S T A D O S F I N A L E S D E L
A U T O M A T A
//Caracter invalido---------------------------------------------------if (nodo.equals("0.0.0
")){
Tokens[numTokens][0] = ("CaracterInvalido")
;
Tokens[numTokens][1] = ("(C)");
numTokens += 1;
word = "";
nodo = "0";
}
//Identificadores------------------------------------------------------if (nodo.equals("0.1.0")){
if (isIdentifier(word)){
Tokens[numToken
s][0] = ("PalabraReservada");
Tokens[numT
okens][1] = (word);
}else{
Tokens[numTokens][0] = ("Identificador");
Tokens[numTokens][1] = (word);
}
numTokens += 1;
word = "";
nodo = "0";
}
//Numero Entero-------------------------------------------------------if (nodo.equals("0.2.0")){
Tokens[numTokens][0] = ("NumeroEntero");
Tokens[numTokens][1] = (word);
numToken
s += 1;
word = "";
nodo = "0";
}
//Numero Real---------------------------------------------------------if
(nodo.equals("0.2.1.0")){
Tokens[numTokens][0] =
("NumeroReal");
Tokens[numTokens][1] = (word);
numTokens += 1;
word
= "";
nodo = "0";
}
//Numero Real---------------------------------------------------------if (nodo.equals("0.2.1.1.0")){
Tokens[numTokens][0] = ("NumeroReal");
Tokens[numTokens][1] = (word);
numTokens +=
1;
word = "";
nod
o = "0";
}
//Punto---------------------------------------------------------------if (nod
o.equals("0.3.0")){
Tokens[numTokens][0] = ("Punt
o");
Tokens[numTokens][1] = (word);
numTokens += 1;
word = "";
nodo = "0";
}
//Coma-----------------------------------------------------------------if (nodo.equals("0.4.0")){
Tokens[numTokens][0] = ("Coma");
Tokens[numToken
s][1] = (word);
numTokens += 1;
word = "";
nodo = "0";

}
----------------------------

//Punto y Coma-----------------------------if (nodo.equals("0.5.0")){

Tokens[numTokens][0] = ("PuntoYComa");
Tokens[numTokens][1] = (word);
numTokens += 1;
word = "";
nodo = "0";
}
//Dos pun
tos-----------------------------------------------------------if (nodo.equals("0.6.0")){
Tokens[numToken
s][0] = ("DosPuntos");
Tokens[numTokens][1] = (wo
rd);
numTokens += 1;
word = "";
nodo = "0";
}
//Dos Puntos Igual----------------------------------------------------if (nodo.equals("0.6.1.0")){
Tokens[numTokens][0] = ("DosPuntosIgual");
Tokens[numTokens][1] = (word);
num
Tokens += 1;
word = "";
nodo = "0";
}
//Parentesis I
zquierdo-------------------------------------------------if (nodo.equals("0.7.0")){
Tokens[numTokens][0]
= ("ParentesisIzq");
Tokens[numTokens][1] = (wor
d);
numTokens += 1;
word = "";
nodo = "0";
}
//Parentesis Derecho--------------------------------------------------if (nodo.equals("0.8.0")){
Tokens[numTokens][0] = ("ParentesisDer");
Tokens[numTokens][1] = (word);
numToke
ns += 1;
word = "";
nodo = "0";
}
//Suma----------------------------------------------------------------if
(nodo.equals("0.9.0")){
Tokens[numTokens][0] = (
"Suma");
Tokens[numTokens][1] = (word);
numTokens += 1;
word = "";
nodo = "0";
}
//Resta---------------------------------------------------------------if (nodo.equals("0.10.0")){
Tokens[numTokens][0] = ("Resta");
Tokens[nu
mTokens][1] = (word);
numTokens += 1;
word = "";
nodo = "0";
}
//Multiplicacion------------------------------------------------------if (nodo.equals("0.11.
0")){
Tokens[numTokens][0] = ("Multiplicacion");
Tokens[numTokens][1] = (word);
numTokens += 1;
word = "";
nodo = "0";
}
//Division-------------------------------------------------------------if (nodo.equals("0.12.0")){
Tok
ens[numTokens][0] = ("Division");
Tokens[numToken
s][1] = (word);
numTokens += 1;
word = "";
nodo = "0";
}
//Div-----------------------------------------------------------------if (nodo.equals("0.13.0")){
Tokens[numTokens][0] = ("Div");
Tokens[numTokens][1] = (word);
numT
okens += 1;
word = "";
nodo = "0";
}
//Mod-----------------------------------------------------------------if (nodo.equals("0.14.0")){
Tokens[numTokens][0]
= ("Mod");
Tokens[numTokens][1] = (word);
numTokens += 1;
word = "
";
nodo = "0";
}

//Menor----------------------------------------------------------if (nodo.equals("0.15.0")){
Tokens[numTokens][0] = ("Menor");
Tokens
[numTokens][1] = (word);
numTokens += 1;
word = "";
nodo = "0";
}
//Menor o Igual-------------------------------------------------------if (nodo.equals("0.
15.1.0")){
Tokens[numTokens][0] = ("MenorIgual");
Tokens[numTokens][1] = (word);
numTokens += 1;
word = "";
nodo = "0";
}
//Mayor----------------------------------------------------------------if (nodo.equals("0.16.0")){
To
kens[numTokens][0] = ("Mayor");
Tokens[numTokens]
[1] = (word);
numTokens += 1;
word = "";
nodo = "0";
}
//Mayor o Igual-------------------------------------------------------if (nodo.equals("0.16.1.0")){
Tokens[numTokens][0] = ("MayorIgual");
Tokens[numTokens][1] = (word);
System.out.println(word);
numTokens += 1;
word = "";
nodo = "0";
}
//Gato----------------------------------------------------------------if (nodo.equals
("0.17.0")){
Tokens[numTokens][0] = ("Gato");
Tokens[numTokens][1] = (word);
numTokens += 1;
word = "";
nodo = "0";
}
/
/Igual----------------------------------------------------------------if (nodo.equals("0.18.0")){
Tokens
[numTokens][0] = ("Igual");
Tokens[numTokens][1]
= (word);
numTokens += 1;
word = "";
nodo = "0";
}
//And-----------------------------------------------------------------if (nodo.equals("0.19.0")){
Tokens[numTokens][0] = ("And");
Tokens[numTokens][1] = (word);
numTokens
+= 1;
word = "";
n
odo = "0";
}
//Or------------------------------------------------------------------if (n
odo.equals("0.20.0")){
Tokens[numTokens][0] = ("O
r");
Tokens[numTokens][1] = (word);
numTokens += 1;
word = "";
nodo = "0";
}
//Not------------------------------------------------------------------if (nodo.equals("0.21.0")){
Tokens[numTokens][0] = ("Not");
Tokens[numToken
s][1] = (word);
numTokens += 1;
word = "";
nodo = "0";
}
//Nueva Linea---------------------------------------------------------if (nodo.equals("0.22.0")){
word = "";
nodo =
"0";
}
//Espacio-------------------------------------------------------------if (nodo.eq
uals("0.23.0")){
word = "";
nodo = "0";
}
//Tabulaci
on-----------------------------------------------------------if (nodo.equals("0.24.0")){
word = "";
nodo = "0";
}
if ((nodo.equals("0")) && (word.equals(""))){
------

}else{

word = word + car;

i++;
}
}/*
for (int I = 0; I<numTokens; I++){
System.out
.println(Tokens[I][0] + " " + Tokens[I][1]);
}*/
return Tokens;
}
///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX///Funcion nodoSigiente: De
vuelve un String para calcular el estado del Automata///XXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
public
static String nodoSiguiente(String nodo, char car){
//guarda el
estado del Automata para poder usarlo en caso de requerirlo
Strin
g nodoT = new String(nodo);
//--------------------------------------------------------------------//Tipo invalido-------------------------------------------------------//--------------------------------------------------------------------if (carTi
po(car)==-1){
if (nodo.equals("0")){ nodo="0.0"; }else{ n
odo = nodoT + ".0"; }
}
//--------------------------------------------------------------------//Tipo caracter-------------------------------------------------------//--------------------------------------------------------------------if
(carTipo(car)==0){
if (nodo.equals("0")){
nodo="0.1";
}else if(nodo.equals("0.1"
)){
nodo="0.1";
}else{
nodo = nodoT + ".0";
}
}
//--------------------------------------------------------------------//Tipo numero---------------------------------------------------------//--------------------------------------------------------------------if (carTipo(car)==1){
if (nodo.equals("0")){
nodo="0.
2";
}else if(nodo.equals("0.2")){
nodo="0.2";
}else if(nodo.equals("0.2.1")){
nodo="0.2.1.1";
}else if(nod
o.equals("0.2.1.1")){
nodo="0.2.1.1";
}else{
nodo = nodoT + ".0";
}
}
//--------------------------------------------------------------------//otros Tipos---------------------------------------------------------//--------------------------------------------------------------------//03
if (car=='.'){
if(nodo.equals("0")){ nodo="
0.3";
}else if (nodo.equals("0.2")){ nodo="0.2.1";
}else{ nodo = nodoT + ".0";
}
}
//04
if (car==','){
if (nodo.equals("0")){ nodo="0.4"; }else{ nodo = nodoT + ".0"; }
}
//05
if (car==';'){
if
(nodo.equals("0")){ nodo="0.5"; }else{ nodo = nodoT + ".0"; }
}
//06
if (car==':'){
if(nod
o.equals("0")){ nodo="0.6"; }else{ nodo = nodoT + ".0"; }
}
//07
if (car=='('){
if(nodo.equ
als("0")){ nodo="0.7"; }else{ nodo = nodoT + ".0"; }
}
//08
if (car==')'){
if(nodo.equals("
0")){ nodo="0.8"; }else{ nodo = nodoT + ".0"; }
}
//09
if (car=='+'){
if (nodo.equals("0")
){ nodo="0.9"; }else{ nodo = nodoT + ".0"; }
}
//
10
if (car=='-'){
if(nodo.equals("0")){ no
do="0.10"; }else{ nodo = nodoT + ".0"; }
}
//11
if (car=='*'){
if(nodo.equals("0")){ nodo="
0.11"; }else{ nodo = nodoT + ".0"; }
}
//12
if (car=='/'){
if(nodo.equals("0")){ nodo="0.12
"; }else{ nodo = nodoT + ".0"; }
}
//13
if (car=='\\'){
if(nodo.equals("0")){ nodo="0.13";
}else{ nodo = nodoT + ".0"; }
}
//14

if (car=='%'){
if(nodo.equals("0")){ nodo="0.14"; }els
e{ nodo = nodoT + ".0"; }
}
//15
i
f (car=='<'){
if(nodo.equals("0")){ nodo="0.15"; }else{ n
odo = nodoT + ".0"; }
}
//16
if (c
ar=='>'){
if(nodo.equals("0")){ nodo="0.16"; }else{ nodo
= nodoT + ".0"; }
}
//17
if (car==
'#'){
if(nodo.equals("0")){ nodo="0.17"; }else{ nodo = no
doT + ".0"; }
}
//18
if (car=='=')
{
if(nodo.equals("0")){ nodo="0.18";
}else if (nodo.equals("0.15")){ nodo="0.15.1";
}else
if (nodo.equals("0.16")){ nodo="0.16.1";
}else{ nodo = n
odoT + ".0";
}
}
//19
if (car=='&'){
if(nodo.equals("0")){ nodo="0.1
9"; }else{ nodo = nodoT + ".0"; }
}
//20
if (car=='|'){
if(nodo.equals("0")){ nodo="0.20";
}else{ nodo = nodoT + ".0"; }
}
//21
if (car=='!'){
if(nodo.equals("0")){ nodo="0.21"; }els
e{ nodo = nodoT + ".0"; }
}
//22
i
f (car=='\n'){
if(nodo.equals("0")){ nodo="0.22"; }else{
nodo = nodoT + ".0"; }
}
//23
if (
car==' '){
if(nodo.equals("0") || nodo.equals("0.23") ){
nodo="0.23"; }else{ nodo = nodoT + ".0"; }
}
//24
if (car=='\t'){
if(nodo.equals("0")){ nod
o="0.24"; }else{ nodo = nodoT + ".0"; }
}
return
nodo;
}
///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX///Funcion isIdentifier: Devuelve ver
dadero si es una palabra reservada///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
public static boolean isI
dentifier (String word){
if ((word.equals("IF"))||
(word.equals("THEN"))||
(word.equals("WHILE"))||
(word.equals("DO"))||
(word.equal
s("PROCEDURE"))||
(word.equals("BEGIN"))||
(word.equals("END"))||
(word.equals("CONST"))||
(word.equals("VAR"))||
(word.equal
s("NUM"))||
(word.equals("AIF")))
{
return (true);
}else{
ret
urn (false);
}
}///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX///Funcion carTipo: Devuelve
0 si es una letra, 1 si es un numero...///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
public static int ca
rTipo(char c){
Character car = new Character (c);
car.toUpperCase(c);
if (
(car=='A') || (c
ar=='B') || (car=='C') || (car=='D') || (car=='E') ||
(ca
r=='F') || (car=='G') || (car=='H') || (car=='I') || (car=='J') ||
(car=='K') || (car=='L') || (car=='M') || (car=='N') ||
(car=='O') || (car=='P') || (car=='Q') || (car=='R') || (car=='S') ||
(car=='T') || (car=='U') || (car=='V') || (car=='W') || (
car=='X') ||
(car=='Y') || (car=='Z')
){
return 0;
}else if(
(car=='0') || (car=='1') || (car=='2') || (car=='3') || (car=='4') ||
(car=='5') || (car=='6') || (car=='7') || (car=='8') || (car=='9')
){
return 1;
}else if(
(car=='.') || (car==',') || (car==';') || (car==':') || (car
=='(') ||
(car==')') || (car=='+') || (car=='-') || (car=
='*') || (car=='/') ||
(car=='%') || (car=='<') || (car==
'>') || (car=='#') || (car=='\\') ||
(car=='=') || (car=
='&') || (car=='|') || (car=='!') || (car=='\n') ||
(car=
='\t') || (car==' ')
){
return 2;
}else {
return -1;
}
}