jueves, 22 de octubre de 2009

Generador de Diagramas UML

StarUML
*****
StarUML es un proyecto de código abierto para desarrollar rapida, flexible, ampliable, completa, y libremente disponible modelos UML.

StarUML esta principalmente escrito en Delphi. Sin embargo, StarUML es un proyecto multi-lenguaje, y no depende especificamente de un lenguaje de programación, de modo que cualquier lenguaje de programación puede ser utilizado para desarrollar StarUML. (por ejemplo, C / C + +, Java, Visual Basic, Delphi, JScript, VBScript, C #, VB.NET, ...)





Descarga: http://staruml.sourceforge.net/en/download.php

lunes, 12 de octubre de 2009

Buscador de Perfiles Msn y Hotmail

»Instrucciones:
1.- Solo escribe la dirección de correo electrónico y después dale a Ver Perfil.
2.- Podrás observar el perfil de la persona que sea aunque no lo tengas agregado en tu MSN.



martes, 29 de septiembre de 2009

Tesis doctoral Hipertexto

Tesis doctoral
Hipertexto: El nuevo concepto de documento en la cultura de la imagen






link
http://www.hipertexto.info/documentos/indice.htm

sábado, 26 de septiembre de 2009

Manual de CCS

Al igual que el manual HTML este manual de CCS es de lo mejor para mi...






link
http://htmlhelp.com/es/reference/css/properties.html

viernes, 25 de septiembre de 2009

Manual de HTML

Quería recopilar un poco de información para crear mi propio manual de HTML, pero otros ya lo han hecho así que solo recordaré este…





link
http://sestud.uv.es/manual.esp/

sábado, 12 de septiembre de 2009

Publicar un fichero Flash

Para subir un archivo Flash: Link
http://img7.xooimage.com/fr/

Deberás guardar muy bien el enlace que te dará cuando finalice la carga del archivo, y procurar que no pese tanto pues solo ralentizara la pagina.
----------------------------------------------------------------------------------------------------
Para insertar un archivo Flash escribir lo siguiente en el modo Edicion HTML:
(Pero hay que tener en cuenta de que no se deben escribir los saltos de linea)
----------------------------------------------------------------------------------------------------
<div style="text-align: center;">
<object id="movie"
type="application/x-shockwave-flash"
data="URLarchivo.swf"
width="ancho"
height="alto" >
<param name="movie" value="URLarchivo /">
<param name="wmode" value="transparent" />
</object>
</div>
----------------------------------------------------------------------------------------------------

viernes, 11 de septiembre de 2009

Colocar Fondo en tu Blogger

En tu blog tienes que ir a diseño>Edicion de Html
Buscar el código siguiente y añadir lo que esta de color rojo

Antes de hacer eso deberías de tener una dirección URL de alguna imagen que tú hayas escogido.

Una opción fácil es subir una imagen de tu computadora en alguna entrada de uno de tus blogs, y una vez publicado copiar la direcciónURL al darle clic derecho en la imagen. Es Importante darle clic derecho a la imagen para copiar la dirección URL.

body {
background:$bgcolor;
margin:0;
color:$textcolor;
font:x-small Georgia Serif;
font-size/* */:/**/small;
font-size: /**/small;
text-align: center;
background-color: #FFFAFA;
background-image: url(http://);
background-attachment: fixed;
background-position: top left;
background-repeat: no-repeat;
border-color: #ffffff;
}



background-color:El color del fondo
background-image:la URL de la imagen que queremos añadir
background-attachment:Con "fixed" le decimos que permanezca fijo cuando bajamos la página
background-position:La posición donde queremos fijar la imagen, en caso de que sea una imagen pequeña
Background-repeat: no-repeat;Que la imagen NO se repita aunque sea pequeña.

lunes, 20 de julio de 2009

Raziel2099


Alguna de las habilidades de mi personaje:

  • Aparecer objetos. Artículos o cosas materiales que no tienen vida.
  • Volar. Durante cierto periodo de tiempo a veces muy largo y otros muy cortos, solo una vez logro hacerlo a una velocidad supersónica.
  • Regresar el tiempo. Aunque se sabe que tiene esa habilidad, solo la ha usado una vez y no ha encontrado la forma de volver a usarla.
  • Licantropía. Puede convertirse en una especie de bestia con velocidad, fuerza, y destreza sobrehumanas, pero le es imposible volver a su estado normal a su antojo
  • Telekinesis. Infinitas capacidades telekineticas aun sin probar todo su alcance. Aunque necesita de concentración para realizarlas (no ocurre tan rápido)
  • Crear fuego. Hacer que cosas se combustionen por si solas, pero con muy pequeños tamaños, o superficies alrededor de 4 metros cuadrados
  • Inmunidad al fuego. Adquirida muy recientemente
  • Atravesar cristales. Adquirida muy recientemente
  • Detener el tiempo. Es sin duda una de las más interesantes, puede llegar a ver incluso las balas en cámara lenta
  • Cambiar escenario. Muy parecida a la teleportacion, sin embargo es el ambiente lo que cambia, o el lugar viene hacia uno difuminándose mientras cambia. Sin embargo su control todavía esta en duda. Sugio como una cualidad incontrolable tras varios intentos de realizar la teleportacion. Su característica es que el lugar al que se viaja no puede ser determinado.
  • Resucitación. Muy parecida a la anterior pues el lugar donde reaparece aunque es muy cercano, tampoco pude ser determinado, además de que no es seguro volver a resurgir, y es muy desagradable.
  • Pelea. Es una de mis favoritas. Diestro en el combate cuerpo a cuerpo, contra uno o varios oponentes sin recibir ningún rasguño, hasta ahora calculo un máximo de 20 oponentes, aunque no lo considero necesario también soy experto en el manejo cualquier tipo de armas de filo.

En consecuencia también mi personaje ha sufrido de efectos secundarios…

  • De ves en cuanto se encuentra con un gemelo que lo vigila desde lejos. Aun no se sabe si es amigo o enemigo, sin embargo se conoce que es casi idéntico a el y tiene sus mismas habilidades (se cree que tendrá que enfrentarse a el)
  • Aunque pocas veces, también se tiene que enfrentar con el señor oscuro, quien lo quiere como su esclavo
  • Nunca recuerda haber hablado con el opuesto al señor oscuro, sin embargo retiene muy pequeñas imágenes de color blanco.
  • En ocasiones no tiene la capacidad de volver a su estado natural o realidad inmediatamente


viernes, 3 de julio de 2009

Generar codigos de barras

Barcode Software 1.0
****
Esta será una de las herramientas que usare para hacer el sistema que podrá leer códigos de barras… mi idea es sencilla, crear una imagen con el código para poder utilizarla a las mil maneras.



Sistema XXI

Listo para realizar mi primer sistema real (nada de tareitas para los demás), será un sistema para el control de un laboratorio de análisis clínicos, pienso hacerlo en PHP y MySQL, aunque también podría empezar por practicar con Netbeans ya veremos.

Comienzo el lunes 6 de julio del 2009… pondré el cronometro para romper mis récords… jajaja

--------------
10/09/2009

El sistema que estaba realizando, pues no llegué a terminarlo ni a entregarlo. Tenía todo para poder desarrollarlo, pero había una idea o molestia que rondaba en mi conciencia y aunque no sabia definirla, finalmente pude comprobar que se trataba de ETICA (bueno eso creo).

Y he decidido no hacerlo, pero gracias a ese sistema he aprendido a manejar matrices de objetos en una página, lo cual no existe pero con algo de creatividad se me ha ocurrido como hacerlo…


martes, 23 de junio de 2009

23

Aunque camine por el valle de las sombras de la muerte no temeré mal alguno, porque tu señor estas conmigo, tu vara y tu cayado son mi consuelo

viernes, 5 de junio de 2009

Tutorial de java en paginas HTML

Este es uno de los manuales que me han servido de ayuda para adentrarme en el mundo de java
Creo que son 15 capítulos, el único inconveniente son los ejemplos ya hechos que no vienen por lo que habría que descargarlos de la pagina principal, sin embargo es una buena lectura para conocer java mas a fondo







Link de descarga
http://www.megaupload.com/?d=SK2V1IM1

Sitio web
http://www.ulpgc.es/otros/tutoriales/java/

Solo lo posteo por ser uno de los dificiles de encontrar

Manual de php en HtmlHelp

Para que aburrirlos con historias... Este es el manual que me ha servido para aprender php








http://mx.php.net/get/php_manual_es.chm/from/a/mirror


Esta en formato HTML help, por lo que es muy útil

miércoles, 8 de abril de 2009

Analizador Léxico en Java

Hola…

Agradezco a todas las personas que me han ayudado a entender la manera de cómo realizarlo y aquellos que me han apoyado cuando he faltado a clases… y por supuesto a Agustín Froufe por proporcionar todo el material necesario apara aprender Java.

Si ya tienes conocimientos de Java puedes pasar de todo esto e ir directamente a descargarte el código y solo ver la imagen del Árbol de decisiones (Autómata) Si deseas aprender java deberías ir a la página de Agustín Froufe…

yo me he pasado horas bajando toda la información para poder leerla. Si tienes dudas sobre lo que son los autómatas podrías investigar mas en Google, aunque dudo mucho que te interese mas de lo que me intereso a mi (que fue mas bien poco).Si lo que quieres es que te ayude a realizar tu maldito (jaja) Analizador Léxico… sigue leyendo:

Antes que nada quiero decirte que el programa que te proporciono puede ser mejorado y digamos que esta a un 98% de ser terminado, solo faltaría que mandes a escribir los Tokens en un archivo.

Quizás podría simplificarse todo el código con el método stringTokenizer() que ya viene en las librerías de Java, pero he tratado de usar un estilo de programación que pueda aplicarse a los lenguajes que mas practico (C++ y Visual Basic) para que otras personas interesadas en dichos lenguajes puedan usarlo.

En fin… Lo primero que tienes que saber es: ¿que es un Analizador Léxico?, y obviamente yo no te lo pienso explicar. Digamos que como yo tienes muy pocos conocimientos de Java, pero ya debes de saber lo básico de manejo y comparación de cadenas, manejo y comparación de caracteres, Arreglos, Funciones y paso de parámetros.

1. Necesitas crear tu lista de símbolos y palabras reservadas, en particular solo me pidieron algo simple:

IF, THEN, WHILE, DO, PROCEDURE, BEGIN, END, CONST, VAR, NUM, AIF, 1234567890

. , ; : ( ) + - * / \ % < <= > >= # = :=

& ! /n ‘ ‘ /t


2. Posteriormente tienes que diseñar lo que yo llamaría un Árbol de Decisiones otros lo conocen como Autómata Finito Discreto

La manera de diseñarlo para mi fue en un principio muy lenta y no me aclaraba muchas dudas a cerca de cómo trabajaría el programa. En base a este se tiene que diseñar una tabla, que aunque no es muy difícil de crear (si se comprende bien), resulta muy tediosa…

Lo que yo muestro en este escrito, es una alternativa a esta manera de crear el diagrama y olvidarte de crear esa enorme tabla.

Estudiando el trabajo de otros, comencé por dibujar el siguiente diagrama en base a los símbolos y palabras que debe aceptar el Analizador Léxico:


Yo quería que el programa trabajara de una manera recursiva (que la función que extrajera los Tokens se llamara así misma y tomara sus propias decisiones), pero en base a este diseño del árbol, también tendría que crear la tabla.

Puesto que no se trata de crear un potente y nuevo lenguaje de programación (en lo cual el uso de la tabla quizás seria de gran ayuda para la velocidad de ejecución) y solo tenemos que crear un analizador léxico. Decidí olvidarme de la tabla y buscar otra manera para que cualquier persona pudiera entender como hacerlo, además de no usar demasiadas variables (reducir la memoria utilizada) y que sea mas lógico de entender… esperando sea de mucha ayuda para ti que estas leyendo.

Cambie un poco la manera de crear el Árbol de Decisiones, quedando de la siguiente manera:


Explicación

Se entiende que en los puntos rojos la decisión se cicla, porque se esta formando una palabra, o un numero, o se esta leyendo espacios, o tabulaciones, o saltos de línea (esto ultimo nunca ocurrirá en el programa pero era bueno tenerlo en cuenta), etc.

Un ejemplo:

Supongamos que estamos en el nodo 0 y el carácter que leímos es una letra, entonces solo se tendrá que pasar al nodo de decisión 0.1 que esta en rojo, y se mantendrá ese estado siempre que escribamos un numero o una letra, en cualquier otro caso pasaremos al estado de decisión 0.1.0, después haremos algo (escribir en un archivo, guardar el Token, presentarlo en pantalla, etc.) y luego volveremos al nodo 0

Fácil no?

Lo mismo será para cualquier otro carácter…

Otro ejemplo:

De alguna manera estamos en el nodo 0.2 y el carácter leído es un punto, pasaremos al estado 0.2.1, en este estado no podemos hacer nada, así que debemos seguir leyendo el siguiente carácter para poder llegar a un estado final, el cual puede ser 0.2.1.0 o 0.2.1.1.0

Comprendido esto puedes ver la estructura del programa:


3. Programar la función

Solo me resta explicar como trabaja la función para analizar las líneas, además de que he incluido comentarios que pueden ayudar a comprender dicha función.

Pudo haber sido más fácil escribir los tokens directamente en el archivo de salida, conforme fueran encontrándose, pero se me antojo mas devolver un arreglo con los tokens encontrados en la línea, simulando a el método stringTokenizer de java.

A la función se le da una cadena de caracteres, ella va analizando carácter por carácter, calculando cual será el siguiente nodo.

nodo = nodoSiguiente(nodo, car);

En base a dicho nodo se tomara una decisión

“SIEMPRE SE AÑADIRÁ EL CARÁCTER A LA PALABRA QUE SE ESTA FORMANDO, AMENOS QUE SE DESEE VOLVER A ANALIZAR EL CARÁCTER, PORQUE ESE CARÁCTER FUE EL CAUSANTE DEL ESTADO FINAL DEL AUTÓMATA”

Por ejemplo tenemos la siguiente línea:

IF;

Si el estado del autómata es 0.1.0 significa que hemos leído el carácter PuntoyComa así que tendremos que procesar la palabra reservada IF, después tendremos que empezar por el nodo 0 volviendo a leer el carácter PuntoyComa para calcular el siguiente estado 0.6

Cuando se llega al final de la línea simplemente se le añade el estado final .0 (por eso decía que nunca se leerá un salto de línea) quedando 0.6.0 por lo que se tendrá que procesar el token PuntoyComa

Lo mismo ocurrirá para todos los símbolos o palabras reservadas.

C:> Presumido modo on

Solo me tomo un par de horas el realizarlo, aunque me tomo mas horas viendo televisión, escuchando música o matando vampiros, para pensar la manera en que quedara de esta forma… fácil de entender y fácil de modificar.

Pienso que cualquier persona con conocimientos básicos podría modificarlo y la verdad no me importa, pues esa era la idea… yo mismo he necesitado la ayuda de otras personas.

Pues bien aquí esta

C:> Presumido modo off




ver codigo

AnalizadorLex.java


No es posible escribir algunas instrucciones en el blog por que lo toma como codigo Script asi que en algun editor de texto

Reemplaza:





/*
* AnalizadorLex.java
* Autor: craneodelrey@msn.com
* Este programa lee un archivo de texto y calcula las parejas ordenadas <[Token],[Lexema]>
* por medio de un Autómata Finito mmm... Determinista
* Lee línea por línea devolviendo un arreglo con los tokens para su manipulación
*/

import java.io.*;
import java.awt.*;
import java.util.*;
public class AnalizadorLex{
>>>---public static String arrayTokens [][];
>>>---public static int numCar = 0;
///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
///Modulo principal
///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
>>>---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");
>>>---}


///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
///Modulo Secundario que lee los Ficheros
///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
>>>---public static void contenidoFichero(String nombreFichero){
>>>--->>>---FileReader elFichero;
>>>--->>>---BufferedReader lector = null;
>>>--->>>---String linea;
>>>--->>>---try{
>>>--->>>--->>>---elFichero = new FileReader(nombreFichero);
>>>--->>>--->>>---lector = new BufferedReader(elFichero);
>>>--->>>--->>>---while((linea = lector.readLine()) != null){
>>>--->>>--->>>--->>>---numCar = linea.length();
>>>--->>>--->>>--->>>---///Por cada linea se devueve un arreglo de N filas y dos columnas con los tokens enontrados
>>>--->>>--->>>--->>>---arrayTokens = separarTokens(linea);
>>>--->>>--->>>--->>>---for (int I = 0; I?arrayTokens.length; I++){
>>>--->>>--->>>--->>>--->>>---System.out.println(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(IOException e){
>>>--->>>---}
>>>---}


///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
///Funcion separarTokens: Devuelve un arreglo de Tokens
///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
>>>---static String [][] separarTokens(String row){
>>>--->>>---int N = row.length();>>>---//longitud de la cadena
>>>--->>>---int i = 0;>>>--->>>--->>>--->>>---//numero de caracter
>>>--->>>---String nodo = "0";>>>--->>>---//estado del automata actual
>>>--->>>---String word = "";>>>--->>>---//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 modificar
>>>--->>>---//el tamaño del "Array de Strings" original
>>>--->>>---String 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 despues del final de la linea por lo que
>>>--->>>--->>>--->>>---//solo se añade el estado final de automata y que la linea nunca estara vacia
>>>--->>>--->>>--->>>---//lo cual es controlado por el modulo en donde se leen los archivos
>>>--->>>--->>>--->>>---nodo = nodo + ".0";
>>>--->>>--->>>--->>>---i++;
>>>--->>>--->>>---}else{
>>>--->>>--->>>--->>>---car = Character.toUpperCase(row.charAt(i));
>>>--->>>--->>>--->>>---nodo = nodoSiguiente(nodo, car);
>>>--->>>--->>>--->>>---
>>>--->>>--->>>---}
/**
La siguente parte es para preparar el Arreglo de Strings y añadir un token cuando 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 funcion devolviera un Arreglo con los tokens
He tratado lo mas posible de que la forma 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 metodos para manejar
correctamente los Strings
*/
>>>--->>>--->>>---if (numTokens != nT){
>>>--->>>--->>>--->>>---///Copio el arreglo original al arreglo temporal para incrementar en numero de filas
>>>--->>>--->>>--->>>---for (int I=0; I?numTokens; I++){
>>>--->>>--->>>--->>>--->>>---TokensT[I][0] = (new String(Tokens[I][0]));
>>>--->>>--->>>--->>>--->>>---TokensT[I][1] = (new String(Tokens[I][1]));
>>>--->>>--->>>--->>>---}
>>>--->>>--->>>--->>>---///Se supone que antes ya se añadio 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 añadiendo nuevas filas despues de añadir 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[numTokens][0] = ("PalabraReservada");
>>>--->>>--->>>--->>>--->>>---Tokens[numTokens][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);
>>>--->>>--->>>--->>>---numTokens += 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 = "";
>>>--->>>--->>>--->>>---nodo = "0";
>>>--->>>--->>>---}
>>>--->>>--->>>---//Punto-----------------------------------------------------------------
>>>--->>>--->>>---if (nodo.equals("0.3.0")){
>>>--->>>--->>>--->>>---Tokens[numTokens][0] = ("Punto");
>>>--->>>--->>>--->>>---Tokens[numTokens][1] = (word);
>>>--->>>--->>>--->>>---numTokens += 1;
>>>--->>>--->>>--->>>---word = "";
>>>--->>>--->>>--->>>---nodo = "0";
>>>--->>>--->>>---}
>>>--->>>--->>>---//Coma------------------------------------------------------------------
>>>--->>>--->>>---if (nodo.equals("0.4.0")){
>>>--->>>--->>>--->>>---Tokens[numTokens][0] = ("Coma");
>>>--->>>--->>>--->>>---Tokens[numTokens][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 puntos------------------------------------------------------------
>>>--->>>--->>>---if (nodo.equals("0.6.0")){
>>>--->>>--->>>--->>>---Tokens[numTokens][0] = ("DosPuntos");
>>>--->>>--->>>--->>>---Tokens[numTokens][1] = (word);
>>>--->>>--->>>--->>>---numTokens += 1;
>>>--->>>--->>>--->>>---word = "";
>>>--->>>--->>>--->>>---nodo = "0";
>>>--->>>--->>>---}
>>>--->>>--->>>---//Dos Puntos Igual------------------------------------------------------
>>>--->>>--->>>---if (nodo.equals("0.6.1.0")){
>>>--->>>--->>>--->>>---Tokens[numTokens][0] = ("DosPuntosIgual");
>>>--->>>--->>>--->>>---Tokens[numTokens][1] = (word);
>>>--->>>--->>>--->>>---numTokens += 1;
>>>--->>>--->>>--->>>---word = "";
>>>--->>>--->>>--->>>---nodo = "0";
>>>--->>>--->>>---}
>>>--->>>--->>>---//Parentesis Izquierdo--------------------------------------------------
>>>--->>>--->>>---if (nodo.equals("0.7.0")){
>>>--->>>--->>>--->>>---Tokens[numTokens][0] = ("ParentesisIzq");
>>>--->>>--->>>--->>>---Tokens[numTokens][1] = (word);
>>>--->>>--->>>--->>>---numTokens += 1;
>>>--->>>--->>>--->>>---word = "";
>>>--->>>--->>>--->>>---nodo = "0";
>>>--->>>--->>>---}
>>>--->>>--->>>---//Parentesis Derecho----------------------------------------------------
>>>--->>>--->>>---if (nodo.equals("0.8.0")){
>>>--->>>--->>>--->>>---Tokens[numTokens][0] = ("ParentesisDer");
>>>--->>>--->>>--->>>---Tokens[numTokens][1] = (word);
>>>--->>>--->>>--->>>---numTokens += 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[numTokens][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")){
>>>--->>>--->>>--->>>---Tokens[numTokens][0] = ("Division");
>>>--->>>--->>>--->>>---Tokens[numTokens][1] = (word);
>>>--->>>--->>>--->>>---numTokens += 1;
>>>--->>>--->>>--->>>---word = "";
>>>--->>>--->>>--->>>---nodo = "0";
>>>--->>>--->>>---}
>>>--->>>--->>>---//Div-------------------------------------------------------------------
>>>--->>>--->>>---if (nodo.equals("0.13.0")){
>>>--->>>--->>>--->>>---Tokens[numTokens][0] = ("Div");
>>>--->>>--->>>--->>>---Tokens[numTokens][1] = (word);
>>>--->>>--->>>--->>>---numTokens += 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")){
>>>--->>>--->>>--->>>---Tokens[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 = "";
>>>--->>>--->>>--->>>---nodo = "0";
>>>--->>>--->>>---}
>>>--->>>--->>>---//Or--------------------------------------------------------------------
>>>--->>>--->>>---if (nodo.equals("0.20.0")){
>>>--->>>--->>>--->>>---Tokens[numTokens][0] = ("Or");
>>>--->>>--->>>--->>>---Tokens[numTokens][1] = (word);
>>>--->>>--->>>--->>>---numTokens += 1;
>>>--->>>--->>>--->>>---word = "";
>>>--->>>--->>>--->>>---nodo = "0";
>>>--->>>--->>>---}
>>>--->>>--->>>---//Not-------------------------------------------------------------------
>>>--->>>--->>>---if (nodo.equals("0.21.0")){
>>>--->>>--->>>--->>>---Tokens[numTokens][0] = ("Not");
>>>--->>>--->>>--->>>---Tokens[numTokens][1] = (word);
>>>--->>>--->>>--->>>---numTokens += 1;
>>>--->>>--->>>--->>>---word = "";
>>>--->>>--->>>--->>>---nodo = "0";
>>>--->>>--->>>---}
>>>--->>>--->>>---//Nueva Linea-----------------------------------------------------------
>>>--->>>--->>>---if (nodo.equals("0.22.0")){
>>>--->>>--->>>--->>>---word = "";
>>>--->>>--->>>--->>>---nodo = "0";
>>>--->>>--->>>---}
>>>--->>>--->>>---//Espacio---------------------------------------------------------------
>>>--->>>--->>>---if (nodo.equals("0.23.0")){
>>>--->>>--->>>--->>>---word = "";
>>>--->>>--->>>--->>>---nodo = "0";
>>>--->>>--->>>---}
>>>--->>>--->>>---//Tabulacion------------------------------------------------------------
>>>--->>>--->>>---if (nodo.equals("0.24.0")){
>>>--->>>--->>>--->>>---word = "";
>>>--->>>--->>>--->>>---nodo = "0";
>>>--->>>--->>>---}
>>>--->>>--->>>---
>>>--->>>--->>>---if ((nodo.equals("0")) YY (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;
>>>---}
>>>---
>>>---
///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
///Funcion nodoSigiente: Devuelve un String para calcular el estado del Automata
///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
>>>---public static String nodoSiguiente(String nodo, char car){
>>>--->>>---//guarda el estado del Automata para poder usarlo en caso de requerirlo
>>>--->>>---String nodoT = new String(nodo);
>>>--->>>---//----------------------------------------------------------------------
>>>--->>>---//Tipo invalido---------------------------------------------------------
>>>--->>>---//----------------------------------------------------------------------
>>>--->>>---if (carTipo(car)==-1){
>>>--->>>--->>>---if (nodo.equals("0")){ nodo="0.0"; }else{ nodo = 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(nodo.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(nodo.equals("0")){ nodo="0.6"; }else{ nodo = nodoT + ".0"; }
>>>--->>>---}
>>>--->>>---//07
>>>--->>>---if (car=='('){
>>>--->>>--->>>---if(nodo.equals("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")){ nodo="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"; }else{ nodo = nodoT + ".0"; }
>>>--->>>---}
>>>--->>>---//15
>>>--->>>---if (car=='<'){ >>>--->>>--->>>---if(nodo.equals("0")){ nodo="0.15"; }else{ nodo = nodoT + ".0"; }
>>>--->>>---}
>>>--->>>---//16
>>>--->>>---if (car=='>'){
>>>--->>>--->>>---if(nodo.equals("0")){ nodo="0.16"; }else{ nodo = nodoT + ".0"; }
>>>--->>>---}
>>>--->>>---//17
>>>--->>>---if (car=='#'){
>>>--->>>--->>>---if(nodo.equals("0")){ nodo="0.17"; }else{ nodo = nodoT + ".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 = nodoT + ".0";
>>>--->>>--->>>---}
>>>--->>>---}
>>>--->>>---//19
>>>--->>>---if (car=='&'){
>>>--->>>--->>>---if(nodo.equals("0")){ nodo="0.19"; }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"; }else{ nodo = nodoT + ".0"; }
>>>--->>>---}
>>>--->>>---//22
>>>--->>>---if (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")){ nodo="0.24"; }else{ nodo = nodoT + ".0"; }
>>>--->>>---}
>>>--->>>---return nodo;
>>>---}
>>>---
>>>---
///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
///Funcion isIdentifier: Devuelve verdadero si es una palabra reservada
///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
>>>---public static boolean isIdentifier (String word){
>>>--->>>---if ((word.equals("IF"))¿?
>>>--->>>--->>>---(word.equals("THEN"))¿?
>>>--->>>--->>>---(word.equals("WHILE"))¿?
>>>--->>>--->>>---(word.equals("DO"))¿?
>>>--->>>--->>>---(word.equals("PROCEDURE"))¿?
>>>--->>>--->>>---(word.equals("BEGIN"))¿?
>>>--->>>--->>>---(word.equals("END"))¿?
>>>--->>>--->>>---(word.equals("CONST"))¿?
>>>--->>>--->>>---(word.equals("VAR"))¿?
>>>--->>>--->>>---(word.equals("NUM"))¿?
>>>--->>>--->>>---(word.equals("AIF")))
>>>--->>>---{
>>>--->>>--->>>---return (true);
>>>--->>>---}else{
>>>--->>>--->>>---return (false);
>>>--->>>---}
>>>---}


///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
///Funcion carTipo: Devuelve 0 si es una letra, 1 si es un numero...
///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
>>>---public static int carTipo(char c){
>>>--->>>---Character car = new Character (c);
>>>--->>>---car.toUpperCase(c);
>>>--->>>---if (
>>>--->>>--->>>---(car=='A') ¿? (car=='B') ¿? (car=='C') ¿? (car=='D') ¿? (car=='E') ¿?
>>>--->>>--->>>---(car=='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;
>>>--->>>---}
>>>---}
}



Aplicando mis nuevos conocimientos, les puedo presentar el código tal y como debería de verse. Aun no lo he compilado, pero estoy seguro de que funcionará.

/* 
* AnalizadorLex.java
* Autor: craneodelrey@msn.com
* Este programa lee un archivo de texto y calcula las parejas ordenadas <[Token],[Lexema]>
* por medio de un Autómata Finito Determinista
* Lee línea por línea devolviendo un arreglo con los tokens para su manipulación
*/

import java.io.*;
import java.awt.*;
import java.util.*;
public class AnalizadorLex{
        public static String arrayTokens [][];
        public static int numCar = 0;
///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
///Modulo principal
///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
        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");
        }


///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
///Modulo Secundario que lee los Ficheros
///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
        public static void contenidoFichero(String nombreFichero){
                FileReader elFichero;
                BufferedReader lector = null;
                String linea;
                try{
                        elFichero = new FileReader(nombreFichero);
                        lector = new BufferedReader(elFichero);
                        while((linea = lector.readLine()) != null){
                                numCar = linea.length();
                                ///Por cada linea se devueve un arreglo de N filas y dos columnas con los tokens enontrados
                                arrayTokens = separarTokens(linea);
                                for (int I = 0; I<arrayTokens.length; I++){
                                        System.out.println(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(IOException e){
                }
        }


///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
///Funcion separarTokens: Devuelve un arreglo de Tokens
///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
        static String [][] separarTokens(String row){
                int N = row.length(); //longitud de la cadena
                int i = 0;                         //numero de caracter
                String nodo = "0";         //estado del automata actual
                String word = "";         //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 modificar
                //el tamaño del "Array de Strings" original
                String 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 despues del final de la linea por lo que
                                //solo se añade el estado final de automata y que la linea nunca estara vacia
                                //lo cual es controlado por el modulo en donde se leen los archivos
                                nodo = nodo + ".0";
                                i++;
                        }else{
                                car = Character.toUpperCase(row.charAt(i));
                                nodo = nodoSiguiente(nodo, car);
                                
                        }
/**
La siguente parte es para preparar el Arreglo de Strings y añadir un token cuando 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 funcion devolviera un Arreglo con los tokens
He tratado lo mas posible de que la forma 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 metodos para manejar
correctamente los Strings
*/
                        if (numTokens !=nT){
                                ///Copio el arreglo original al arreglo temporal para incrementar en numero de filas
                                for (int I=0; I<numTokens; I++){
                                        TokensT[I][0] = (new String(Tokens[I][0]));
                                        TokensT[I][1] = (new String(Tokens[I][1]));
                                }
                                ///Se supone que antes ya se añadio 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 añadiendo nuevas filas despues de añadir 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[numTokens][0] = ("PalabraReservada");
                                        Tokens[numTokens][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);
                                numTokens += 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 = "";
                                nodo = "0";
                        }
                        //Punto-----------------------------------------------------------------
                        if (nodo.equals("0.3.0")){
                                Tokens[numTokens][0] = ("Punto");
                                Tokens[numTokens][1] = (word);
                                numTokens += 1;
                                word = "";
                                nodo = "0";
                        }
                        //Coma------------------------------------------------------------------
                        if (nodo.equals("0.4.0")){
                                Tokens[numTokens][0] = ("Coma");
                                Tokens[numTokens][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 puntos------------------------------------------------------------
                        if (nodo.equals("0.6.0")){
                                Tokens[numTokens][0] = ("DosPuntos");
                                Tokens[numTokens][1] = (word);
                                numTokens += 1;
                                word = "";
                                nodo = "0";
                        }
                        //Dos Puntos Igual------------------------------------------------------
                        if (nodo.equals("0.6.1.0")){
                                Tokens[numTokens][0] = ("DosPuntosIgual");
                                Tokens[numTokens][1] = (word);
                                numTokens += 1;
                                word = "";
                                nodo = "0";
                        }
                        //Parentesis Izquierdo--------------------------------------------------
                        if (nodo.equals("0.7.0")){
                                Tokens[numTokens][0] = ("ParentesisIzq");
                                Tokens[numTokens][1] = (word);
                                numTokens += 1;
                                word = "";
                                nodo = "0";
                        }
                        //Parentesis Derecho----------------------------------------------------
                        if (nodo.equals("0.8.0")){
                                Tokens[numTokens][0] = ("ParentesisDer");
                                Tokens[numTokens][1] = (word);
                                numTokens += 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[numTokens][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")){
                                Tokens[numTokens][0] = ("Division");
                                Tokens[numTokens][1] = (word);
                                numTokens += 1;
                                word = "";
                                nodo = "0";
                        }
                        //Div-------------------------------------------------------------------
                        if (nodo.equals("0.13.0")){
                                Tokens[numTokens][0] = ("Div");
                                Tokens[numTokens][1] = (word);
                                numTokens += 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")){
                                Tokens[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 = "";
                                nodo = "0";
                        }
                        //Or--------------------------------------------------------------------
                        if (nodo.equals("0.20.0")){
                                Tokens[numTokens][0] = ("Or");
                                Tokens[numTokens][1] = (word);
                                numTokens += 1;
                                word = "";
                                nodo = "0";
                        }
                        //Not-------------------------------------------------------------------
                        if (nodo.equals("0.21.0")){
                                Tokens[numTokens][0] = ("Not");
                                Tokens[numTokens][1] = (word);
                                numTokens += 1;
                                word = "";
                                nodo = "0";
                        }
                        //Nueva Linea-----------------------------------------------------------
                        if (nodo.equals("0.22.0")){
                                word = "";
                                nodo = "0";
                        }
                        //Espacio---------------------------------------------------------------
                        if (nodo.equals("0.23.0")){
                                word = "";
                                nodo = "0";
                        }
                        //Tabulacion------------------------------------------------------------
                        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;
        }
        
        
///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
///Funcion nodoSigiente: Devuelve un String para calcular el estado del Automata
///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
        public static String nodoSiguiente(String nodo, char car){
                //guarda el estado del Automata para poder usarlo en caso de requerirlo
                String nodoT = new String(nodo);
                //----------------------------------------------------------------------
                //Tipo invalido---------------------------------------------------------
                //----------------------------------------------------------------------
                if (carTipo(car)==-1){
                        if (nodo.equals("0")){ nodo="0.0"; }else{ nodo = 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(nodo.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(nodo.equals("0")){ nodo="0.6"; }else{ nodo = nodoT + ".0"; }
                }
                //07
                if (car=='('){
                        if(nodo.equals("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")){ nodo="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"; }else{ nodo = nodoT + ".0"; }
                }
                //15
                if (car=='<'){
                        if(nodo.equals("0")){ nodo="0.15"; }else{ nodo = nodoT + ".0"; }
                }
                //16
                if (car=='>'){
                        if(nodo.equals("0")){ nodo="0.16"; }else{ nodo = nodoT + ".0"; }
                }
                //17
                if (car=='#'){
                        if(nodo.equals("0")){ nodo="0.17"; }else{ nodo = nodoT + ".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 = nodoT + ".0";
                        }
                }
                //19
                if (car=='&'){
                        if(nodo.equals("0")){ nodo="0.19"; }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"; }else{ nodo = nodoT + ".0"; }
                }
                //22
                if (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")){ nodo="0.24"; }else{ nodo = nodoT + ".0"; }
                }
                return nodo;
        }
        
        
///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
///Funcion isIdentifier: Devuelve verdadero si es una palabra reservada
///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
        public static boolean isIdentifier (String word){
                if ((word.equals("IF"))||
                        (word.equals("THEN"))||
                        (word.equals("WHILE"))||
                        (word.equals("DO"))||
                        (word.equals("PROCEDURE"))||
                        (word.equals("BEGIN"))||
                        (word.equals("END"))||
                        (word.equals("CONST"))||
                        (word.equals("VAR"))||
                        (word.equals("NUM"))||
                        (word.equals("AIF")))
                {
                        return (true);
                }else{
                        return (false);
                }
        }


///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
///Funcion carTipo: Devuelve 0 si es una letra, 1 si es un numero...
///XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
        public static int carTipo(char c){
                Character car = new Character (c);
                car.toUpperCase(c);
                if (
                        (car=='A') || (car=='B') || (car=='C') || (car=='D') || (car=='E') ||
                        (car=='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;
                }
        }
}


El programa necesita del archivo “Test.plo”, mismo que de veras crear y situarlo en la misma carpeta donde se genera el archivo “AnalizadorLex.class”

Donwload
From SkyDrive