Tecnopatico

El extremo de atrás

2005-12-04T21:45:00.000-06:00

Una de las etapas que requieren más cuidado, es la comprbación de tipos. Se requiere ser bastante meticuloso y analizar la gramática para tener presente dónde y cuándo hecer las verificaciones. Un descubrimiento agradable fue el encontrar que si se tiende a ser estricto y no permitor conversiones implícitas, la comprobación de tipos es capaz de alertar al mismo tiempo de ciertos errores menos perceptibles. Por ejemplo, si se utiliza el tipo "void" como tipo de retorno de una sentencia(statement) o de un procedimiento, aunque este tipo no esté disponible para el usuario, el uso de un procedimiento donde se espera una función o viceversa, se puede detectar como un error de tipos. A pesar de ello, una comprobación intencionalmete diseñada para capturar tal falla puede ser una mejor estrategia si se desea reportar con mensajes más explicativos.

Después de la etapa de comprobación de tipos, queda la generación del código intermedio. En este proyecto se pueden aplicar ciertas simplificaciones que son de mucha utilidad; tal como el asumir que todo error que se pueda capturar en la etapa de parseo, se capturará ahi, de manera que el código intermedio quedará de una vez, limpio y libre de errores.

Tal como su nombre lo indica, este producto representa el punto limítrofe entre la parte frontal y la posterior del compilador. Es interesante notar, que la representación intermedia es por sí misma, un lenguaje, y como tal es lejanamente factible escribir código de programación directamente en una representación "neutral". En teoría, cualquier lenguaje fuente puede traducirse a un determinado código intermedio, y un codigo intermedio puede traducirse a código fuente de otro lenguaje, ensamblador o código objeto(binario) de cualquier máquina. El código intermedio es, de todas formas, casi tan confuso de entender como el propio ensamblador, y varía demasiado, pues, a pesar de existir ciertos patrones de diseño, queda a conveniencia de autor del compilador utilizar la técnica que mejor se ajuste a la orientación que se adopte para el compilador.

Lo anterior me lleva a concluir que seguramente, cuando se traduce de código intermedio hacia cualquier otro, se debe asumir que fué generado por la parte frontal de un compilador y que por lo tanto, está libre de errores, ya que sería un desperdicio de recursos el hacer verificaciones en esta etapa intermedia. En el caso de este proyecto, resulta mucho más cómodo y seguro, producir el código intermedio como una estructura de datos y trabajar "en memoria", para evitar el tenr que pasar por un archivo, como es el caso de muchos compiladores profesionales. Queda claro, que ese archivo se utiliza bien por limitaciones técnicas, o por razones tales como el enlace de código escrito en varios archivos fuente distintos(probablemente en distintos lenguajes).

Otra conclusión importante, es que el uso de la tabla de símbolos es tan necesario y provechoso tanto en la etapa frontal como en la posterior; asimismo la libertad de diseño que permiten las herramientas modernas tales como el lenguaje JAVA y las computadoras de (por ahora)alta capacidad, como las actuales, facilitan sobremanera la realización de un compilador, ya que se eliminan muchas de las restricciones de espacio en memoria, algunos de los problemas de rendimiento(cuando se trate de compiladores pequeños a medianos) y el tamaño del código del compilador propiamente dicho. Aparentemente, de esta ventaja se a abusado en plataformas tales como .NET (joke?).

Implementacion de la representación intermedia.
Hay dos formas casi diferentes de implementar el código intermedio. La que he preferido es la de construir un arbol de sintaxis abstracta linealizado, utilizando una estructura de ArrayList, donde se guardan estructuras que hacen el papel de Cuads. Estas estructuras constan de un operador, dos operandos, y un resultado. Dependiendo del operador se evaluan los operandos, pudiendo éstos representar valores inmediatos, como en las hojas del árbol, o bien cursores a otras casillas en el mismo ArrayList, como en el caso de los nodos interiores. Los operandos pueden también representar índices de la Tabla de símbolos.

En este proyecto, el Arbol de sintaxis abstracta se construye de forma que siempre, al momento de crear un nodo que tiene hijos, éstos han sido previamente creados. Por otra parte, cada vez que se crea un nodo(u hoja), se inserta en la lista, y se retorna el índice en el cual sucedió la inserción, incrementando en uno el índice con cada inserción. Estos índices se hacen circular a través de la gramática como atributos sintetizados, permitiendo la fácil creacion de nuevos árboles a partir de los ya existentes. Esta forma de trabajo permite garantizar que para cualquier nodo con hijos, se cumple que el índice de los hijos es siempre menor que el índice del padre.

Este detalle se puede aprovechar de la siguiente manera:
El miembro "resultado" de los cuads se deja vacío al momento de la creación inicial del AST. El AST se recorre de acuerdo al índice de los nodos; siempre se visitará primero a los hijos, por lo cual, se puede asignar correctmente a "resultado" el valor conveniente, ya que cuando el padre de dicho nodo lo requiera, está garantizado que tal valor ya ha sido asignado.

Lo más importante de esta estrategia, es que permite la fácil asignación de registros a las expresiones en el momento del paso de la representación intermedia a ensamblador. Los registros asignados a los hijos se pueden liberar cuando se calcula el valor del padre.

Por otra parte, el asignar el resultado de los operadores binarios a uno de los registros de los operandos reduce el numero de registros necesarios para ciertos cálculos: por ejemplo para 3 + 4, en lugar de

add $t2, $t0, $t1

se puede hacer asi:

add $t0, $t0, $t1

de esta forma, se evita el tener que buscar un registro libre para el resultado, y se evita la operacion de liberar uno de los registros.

La parte referenta a los stack frames, resulta severamente difícil de entender, sin embargo no es igual de programar, ya que se trata en realidad de un segmento de código que es constante, al menos parcialmente. Claro, que esto ayudado en gran medida por la simplificación de usar palabras tanto para enteros como caracteres. Aun queda por resolver la temática de los arreglos, no obstante, parece sensato comprobar primero que las variables de tamaño constante son correctamente procesadas para despues comenzar con los arreglos. Con esto en mente, es recomendable calcular los despazamientos(offset) de manera incremental y no multiplicativa, ya que arreglos de cualquier tamaño pueden declararse entre variables de tamaño constante, por lo que simplemente multiplicar el numero de orden de declaración por el ancho de palabra es un tanto contraproducente.

En un comentario final, las estructuras de control ofrecen también un reto de estudio, pues, dado que el asembler se ejecuta secuencialmente, se debe analizar bien la colocación de los saltos y bifurcaiones.

Convenciones de llamada y parametros variantes

2005-11-27T22:02:00.000-06:00

Aunque debo admitir, que no investigué mucho, las principales diferencias entre MIPS e INTEL, al menos las que puedo señalar empiricamente, es, por supuesto, que INTEL pasa parámetros via stack, mientras que MIPS dispone de cuatro registros especiales para ello. Aunque Tambien es cierto que en MIPS podría hacerse todo el paso de parametros por medio del stack. No se para que, pero alguien podría estar usando esos cuatro registros para otra cosa.

Fuera de eso, lo más que sé al respecto, es que, MIPS es arquitectura RISC, mientras INTEL es CISC. Eso significa que MIPS posee un juego de Instrucciones reducido, mientras que Intel, tiene uno extendido. En lo que a mi respecta, eso significa que Intel tiene instrucciones equivalente a la secuencia de Varias instrucciones, lo cual por ejemplo, permite que lo que MIPS hace en dos o más instrucciones, INTEL lo puede hacer en una sola instruccion atómica.

En Realidad, el tema RISC vrs CISC es sumamente extenso, dado que se trata de filosofías de diseño, y como tales, tienen ventajas y desventajas...

En cuanto a la segunda pregunta, pues, si, en efecto hice el programa, pero solo fue "un vil copy-paste" de un ejemplo que encontre en MSDN.

De modo que decidí hacer algo parecido, pero escarbando un poquito, usando direcciones de memoria para ver algunas cosas...

Lo primero que hice, es ver la direccion de memoria de los parámetros, para constatar sus posiciones relativas en la menmoria. Pude confirmar, que C, introduce primero el último parámetro, dejando el primero más cerca del tope del stack. En el ejemplo que proporciono se puede ver como second está en la direccion de memoria siguiente a first.

Eso me indujo a mi siguiente experimento. Dado el procedimiento cuyos parámetros son todos de tipo int, es posible declarar un int*, y asignarle la direccion del primer parámetro. El resultado, si se tiene:
int * ptr = &primerParam
Entonces se puede decir:
ptr[0] = ///
ptr[1] = ///
/// = ptr[n],
donde ptr[n] es el (n+1)-ésimo parámetro.

En mi experimento, pude accesar todos los parámetros, indistintamente si éstos eran fijos o variantes.

ABRE-PARENTESIS

No hay manera de saber cuantos parámetros se han enviado, al menos desde el lado del callee, si no se utiliza algun terminador, bandera, valor especial, ... etc. ni siquiera mediante las macros va_start, va_arg, o va_end (que no se que hace por cierto), y esto, aun en las versiones ansi y unix.

Solamente el caller "sabe exactamente" cuantos argumentos utilizó en la llamada.

Aqui entra en juego el asunto de las CALLING_CONVENTIONS.
En las lecturas que hice, encontré lo siguiente:

hay basicamente tres: __stdcall, __cdecl, y __fastcall.

En realidad no encontré una diferencia entre las dos primeras, excepto que en __cdecl, el caller es el responsable de sacar los parametros del stack una vez que la llamada retorna; no así en __stdcall, donde es el callee el encargado.

En cuanto al orden de los parámetros en la pila, experimenté con __stdcall y con __cdecl, en ambas obtuve las mismas direcciones relativas entre parámetros, i.e. no vi ningun cambio, el primer argumento está siempre mas cerca del tope de la pila que los demás.

De hecho, eso también lo leí por ahi en mis averiguatos.

En lo que más relevancia encontre que la diferenciacion era importante, es en el tema ya de enlace de símbolos (linking), donde tienen mucho que estudiar los que desarrollan DLL, (Dynamic Link Libraries). Aqui lo importante es que, si hay una disparidad entre convenciones de llamada, (que un lado utilice __stdcall y el otro __cdecl) la pila se ve destruida, pues bien, o nadie hace "pop", o ambos lo harán, ( y la máquina hace "puff" y uno queda con "cara de what?").

En un comantario sin importancia, hasta ahora sé porque hay que ponerle __stdcall a las funciones que uno usa en una DLL, jeje, por cierto, eso de #define, es mala manía, porque en las DLL uno usa DLLIMPORT, pero al final, #define DLLIMPORT __stdcall. (Ni los mareros usan tanto alias...)

La consistencia entre convenciones de llamada es también crucial en los casos en que una aplicación se desarrolla desde varios lenguajes.

en cuanto a __fastcall, basicamente utiliza registros para pasar parámetros, pero como no todos los registros estarán disponibles, a fin de cuentas el compilador terminará decidiendo cuales poner y cuales no...

El otro punto a que encontré, concerniente a convenciones, tiene tambien que ver con linking, esta vez con los nombres decorados o "mangling", que es cuando los editores de enlace (equivalente de linkers) cambian los nombres de las funciones, "decorandolos" con simbologías que indican tipo de convencion de llamada, tipo y/o numero de parametros, etc. El "name mangling" depende del diseño del linker.

CIERRA-PARENTESIS

Tambien quise ver las variables locales, y constaté que se menten en la pila en el orden en que se declaran, y despues que los argumentos, es decir asi:

(direcciones bajas/tope)
...
variables locales
8 Bytes que no se que son
arg1
arg2
...
argn
...
(direcciones altas/fondo de pila)

Codigo Usado en el experimento final:

____________________________________________

#include
#include
#include

int recorre4(int first, int second, int third...){
printf("&first =%i\n&second=%i\n&third =%i\n",&first, &second, &amp;third);
int a,b,c,d;
a = 1;
b = 2;
c = 3;
d = 4;
printf("\n&a=%i\n&b=%i\n&c=%i\n&d=%i\n",&a,&amp;b,&c,&d);
int* ptr; ptr = &first;
printf("&p=%i\n",&amp;ptr);
int x,y,z;
printf("\n&x=%i\n&y=%i\n&z=%i\n",&amp;x,&y,&z);
printf("ptr:[%i][%i][%i][%i][%i][%i]\n",ptr[0],ptr[1],ptr[2],ptr[3],ptr[4],ptr[5]);
printf("ptr[7] = = = :%i\n", ptr[7]);
printf("ptr[6] = = = :%i\n", ptr[6]);
printf("arriba^5 de a:%i\n", *(&a+5));
printf("arriba^4 de a:%i\n", *(&a+4));
printf("arriba^3 de a:%i\n", *(&a+3));
printf("arriba^2 de a:%i\n", *(&a+2));
printf("arriba de a:%i\n", *(&a+1));
printf("arriba de b:%i\n", *(&b+1));
printf("arriba de c:%i\n", *(&c+1));
printf("exactamente c:%i\n", *(&c));
printf("debajo de c:%i\n", *(&c-1));
printf("debajo^2 de c:%i\n", *(&c-2));
printf("debajo^3 de c:%i\n", *(&c-3));
//return 224;
}

int __stdcall normal(int m, int n, int o){
int s, t, u;
printf("&m := %i\n", &amp;m);
printf("&n := %i\n", &amp;n);
printf("&o := %i\n", &amp;o);
printf("&s := %i\n", &s);
printf("&t := %i\n", &amp;t);
printf("&u := %i\n", &amp;u);
}

int main(){
int r1 = recorre4(2,5,6,7,8,0);
printf(" retorna %i\n", r1);
int r2 = recorre4(2,5,6,7,8,0);
printf(" retorna %i\n", r2);
printf("\n");
system("pause");
normal(1,2,3);
system("pause");
return 0;
}
____________________________________________

SALIDA
____________________________________________

&first =37814056
&second=37814060
&third =37814064

&a=37814044
&b=37814040
&c=37814036
&d=37814032
&p=37814028

&x=37814024
&y=37814020
&z=37814016
ptr:[2][5][6][7][8][0]
ptr[7] = = = :4200443
ptr[6] = = = :37814112
arriba^5 de a:6
arriba^4 de a:5
arriba^3 de a:2
arriba^2 de a:4200463
arriba de a:37814112
arriba de b:1
arriba de c:2
exactamente c:3
debajo de c:4
debajo^2 de c:37814056
debajo^3 de c:4200624
retorna 22
&first =37814056
&second=37814060
&third =37814064

&a=37814044
&b=37814040
&c=37814036
&d=37814032
&p=37814028

&x=37814024
&y=37814020
&z=37814016
ptr:[2][5][6][7][8][0]
ptr[7] = = = :4200443
ptr[6] = = = :37814112
arriba^5 de a:6
arriba^4 de a:5
arriba^3 de a:2
arriba^2 de a:4200511
arriba de a:37814112
arriba de b:1
arriba de c:2
exactamente c:3
debajo de c:4
debajo^2 de c:37814056
debajo^3 de c:2147332096
retorna 25

Press any key to continue . . .
&m := 37814072
&n := 37814076
&o := 37814080
&s := 37814060
&t := 37814056
&u := 37814052
Press any key to continue . . .

____________________________________________

Uso de atributos heredados en CUP(parte 2)

2005-11-14T00:52:00.000-06:00

Confirmada mi sospecha, usar el código raro... funciona.
Esta vez utilicé una gramatica similar a la declaración de tipos en C/C++;
la cual es:

dec -> dec tipo lista ';'
dec -> tipo lista ';'
tipo -> entero
tipo -> real
lista -> lista ',' ID
lista -> ID

Las reglas semanticas embebidas en la gramatica, originalmente quedan:

dec -> dec tipo {lista.t = tipo.t} lista ';'
dec -> tipo {lista.t = tipo.t} lista ';'
tipo -> entero {tipo.t = entero}
tipo -> real {tipo.t = real}
lista -> {lista1.t = lista.t} lista ',' ID {declare(ID.lexema, lista.t);}
lista -> ID{declare(ID.lexema, lista.t);}

por la regla de copia, se sustituyen las referencias al atr.heredado por referencias al

atributo sintetizado del símbolo de orígen, por lo tanto, las producciones de lista

quedan:

lista -> lista ',' ID {declare(ID.lexema, lista.t);} // usando atr[top-3]
lista -> ID{declare(ID.lexema, lista.t);} // usando atr[top-1]

aca pueden ver el código de cup.
----------------------------------------------------------------
package EjemploH1;

import java.io.*;
import java_cup.runtime.*;

parser code {:

public static void main(String args[]) throws Exception {
try{
//FileReader fis = new FileReader("dec.txt"); // se construye el File reader
parser paspar = new parser(new Yylex(System.in));
paspar.parse();
System.out.println("Proceso terminado");
System.exit(0);
}catch(FileNotFoundException e){
System.out.println("Imposible abrir el erchivo especificado");
System.exit(1);
}
}
:}

action code {:

private void settype(String id, String tipo){
System.out.println("declare(" + id + ", tipo " + tipo + ");");
}

:}

terminal ENTERO, REAL, COMA, PUNTOYCOMA;
terminal String ID;

non terminal cSimbolo dec, tipo, lista;

dec ::= dec tipo lista PUNTOYCOMA;

dec ::= tipo lista PUNTOYCOMA;

tipo ::= ENTERO {:RESULT = new cSimbolo("entero"); :};

tipo ::= REAL {:RESULT = new cSimbolo("real"); :};

lista ::= lista COMA ID:i{:settype(i,((cSimbolo)((java_cup.runtime.Symbol)

CUP$parser$stack.elementAt(CUP$parser$top-3)).value).tipo);:};

lista ::= ID:i {:settype(i,((cSimbolo)((java_cup.runtime.Symbol)

CUP$parser$stack.elementAt(CUP$parser$top-1)).value).tipo);:};

----------------------------------------------------------------

Aqui un ejemplo de corrida:

----------------------------------------------------------------
entero lunes, martes, miercoles; real madrid, fantasia, cuento;
declare(lunes, tipo entero);
declare(martes, tipo entero);
declare(miercoles, tipo entero);
declare(madrid, tipo real);
declare(fantasia, tipo real);
declare(cuento, tipo real);
^Z
Proceso terminado
Press any key to continue...
----------------------------------------------------------------

y por si las dudas, el código de jFlex:
----------------------------------------------------------------
package EjemploH1;

import java_cup.runtime.Symbol;

/**
* Class YyLex, creada mediante jFlex a partir de minimal. lex.
* @author Gerson Lara
* @URL http://www2.cs.tum.edu/projects/cup/minimal.tar.gz
*/
%%
%cup
%ignorecase
%%
";" { return new Symbol(sym.PUNTOYCOMA); }
"entero" { return new Symbol(sym.ENTERO); }
"real" { return new Symbol(sym.REAL); }
"," { return new Symbol(sym.COMA); }
[A-Za-z]+ { return new Symbol(sym.ID, yytext()); }
[ \t\r\n\f] { /* ignore white space. */ }
. { System.err.println("Illegal character: "+yytext()); }
----------------------------------------------------------------

Cambios en la carrera.

2005-11-13T22:20:00.000-06:00

Recientemente {asist ( í | imos ) } a una reunión para informarnos a cerca de los cambios que se avecinan en el plan de estudios de la Carrera de Sistemas en Unitec.

Lo que queiro mencionar aquí es mi satisfacción por el hecho de que ahora se va a considerar la falla (ya mencionada antes) de la gente de sistemas para trabajar en grupos multidisciplinarios.

Me permito recordar que si bien es cierto, la carrera es eminenetemente técnica, eventualmete nos corresponderá fungir como administradores de algun departamento o empresa, deseablemente relativa al tema computacional. Y esto lo digo no con ánimos de insistir, sino de apoyar esa decisión en particular de la jefatura de la carrera.

En mi posición particular, el software administrativo, no me agrada (aunque quizá sea el que más venda), prefiero verme como parte de un equipo de desarrollo o investigación sobre nuevas tecnologías, o apoyar proyectos de investigación científica o algo así. Aquí inserto mi frase de "La computación por sí sola no sirve para nada". Digo esto porque (no lo tomen a mal pero,) un autómata ahi solito, sólo sirve para quebrarse la cabeza. Ahora, asocie ese autómata con um problema real, y al resolver el autómata, debería tener la solución del problema original. Suena obvio, y creo que lo es, sin embargo, al trasladar esto un poco más a flote, La gente de Sistemas tiende a pensar que con saber de Sistemas y computadores, bits y bytes, y si se queire cables y frecuencias basta. Pero y a la hora de desarrollar un proyecto que integre personas y tecnología? quién sabe de personas? De alumnos un docente, de pacientes el doctor, de empleados el de Recursos Humanos que con suerte es Psicólogo... La computación sirve cuando se le combina adecuadamente con otra ciencia, arte, deporte, empleo etc... El caso es que, con suerte( no se si buena o mala) me corresponderá algún día, liderar o administrar un grupo como esos, donde cada quien piensa que su propio gremio es lo máximo. ¿Cómo ponerlos de acuerdo?

Por eso creo que le viene bien a Sistemas de Unitec, la carrera "donde se enseña cómo hacer y no cómo usar..." , que le incluyan un par de clases y talleres de liderazgo, para aprender a quitarnos eso de "Porque si, porque yo se de computadoras y (vos | usted | etc ) no!" (Que aunque no lo decimos, lo pensamos)

Una de las últimas clases que incluye el plan 2002 para sistemas, donde se puede trabajar en grupos multidisciplinarios, es Generación de Empresas I, clase que en lo personal, opino que es un desastre; vayan a ver a los de Sistemas, Todos Juntos!!!! Parece que le tienen miedo a los de Publicidad y por eso no se juntan con ellos, como si les fueran a robar los poderes divinos o algo.

Finalmente, comento que alguien me dijo, que en su caso, cuando estudió, era requisito, que en cada período, debía inscribir una clase al menos, no relacionada con el área, es decir, Finanzas, Biología, Arte, ... Unitec podría hacer eso, aunque copiar comportamientos nunca es bueno, eso si los iba a enojar, en lugar de eso, ahi colocaron unos talleres no más, asi que ¡Enhorabuena por los cambios!!!

Uso de Atributos heredados en CUP (parte 1)

2005-11-13T21:57:00.000-06:00

Lo primero que se me ocurrió fue usar una porción de codigo copiada del código generado. había visto antes eso de top-x, y cuando se hizo la pregunta, yo creí conocer la respuesta.
La verdad solamente había vista la punta de in iceberg.
Al intentar colocar acciones enmbebidas en la gramática se genera una cantidad alta de conflictos shift/reduce; el insertar los marcadores manualmente, procuce (al menos en mis pruebas) exactamente los mismos conflictos.
El mayor problema con esos conflictos, es que , aunque CUP tiene una políitica establecida para resolverlos, también aborta la generación de código, por lo cual, nunca pude probar si mi especulación era correcta.

El código que pensaba emplear eran las respectivas versiones de algo como esto:
cSimbolo E = (cSimbolo)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value;
Pero el problema no fue escribir eso, sino hacer que CUP generase el código.

De modo que sigo con la interrogante a cuestas.

Por cierto, aun me queda otra duda:

Si en A -> XYZ, o mejor en S -> XYZ, donde S es el START SYMBOL o uno similar, ¿Cómo puede utilizarse un atributo de S en los hijos de S? ¿No ha reducido ni se ha metido en la pila, entonces de donde toma su valor? y ya que estamos, fuera de ese caso, ¿Para cualquier necesidad de un valor de atributo de Y por parte de un hijo de Y, debe sustituirse por el correspondiente atributo del símbolo del cual hereda el atributo? o hay casos donde no es posible ?(Sólo en L-atribuidas)

Tarea

2005-11-06T23:50:00.000-06:00

Gramatica para ejerc 6.3
P -> D;E

D -> D;D
D -> id:T { declare(id.nombre, T.tipo) }

T -> char { T.tipo = char }
T -> integer { T.tipo = integer }
T -> list of T1 { T.tipo = tipo_lista(T1.tipo) }

E -> literal { E.tipo = char }
E -> num { E.tipo = integer }
E -> id { E.tipo = tipode(id.nombre) }
E -> ( L ) { E.tipo = L.tipo }

L -> E,L1 { L.tipo = si( E.tipo==(L1.tipo).tipo, tipo_lista(E.tipo, L1.tipo), error_tipo) }
L -> E { L.tipo = E.tipo }

Notas: asuma que: declare() graba a la TDS, tipode() busca en la TDS y retorna el tipo y si() es una funcion que toma un valor booleano y dos expresiones, si el valor es true, retorna el valor de la primera expresion, sino el de la segunda.

EJERCICIO 6.5a (interprete lo que está entre llaves como las "decoraciones del arbol". El árbol está dibujado como en el "treeview" de windows.)
P
+-D
| +-D {declara(id.lexema, T.tipo)}
| | +-id {id.lexema = "c"}
| | | +-c
| | +-:
| | +-T {T.tipo = char}
| | +-char
| +-;
| +-D {declara(id.lexema, T.tipo)}
| +-id {id.lexema = "i"}
| | +-i
| +-:
| +-T {T.tipo = integer}
| +-integer
+-;
+-E {E1.tipo==char && E2.tipo==integer entornces error_tipo}
+-E1 {E1.tipo = tipode(id.lexema)//char}
| +-id {id.lexema="c"}
| +-c
+-mod
+-E2 {E3.tipo==integer && E4.tipo==integer entonces integer}
+-E3 {E3.tipo=tipode(id.lexema)//integer}
| +-id {id.lexema="i"}
| +-i
+-mod
+-E4 {E.tipo = integer}
+-num
+-3

TDS:[id,tipo]
[c,char]
[i,ineger]

EJERCICIO 6.5b
P
+-D
| +-D { declare(id.lexema, T1.tipo) }
| | +-id {id.lexema="p"}
| | | +-p
| | +-:
| | +-T1 {T1.tipo = pointer(integer)}
| | +-^
| | +-integer
| +-;
| +-D {declare(id.lexema,T3.tipo)}
| +-id {id.lexema = "a"}
| | +-a
| +-:
| +-T3 {T3.tipo = array(num.val, T2.tipo)}
| +-array
| +-[
| +-num {num.val = 10}
| | +-10
| +-]
| +-of
| +-T2 {T2.tipo = integer}
| +-integer
+-;
+-E {E.tipo = E3.tipo == integer && E1.tipo == array(s,t) entonces t //integer}
+-E1 {E1.tipo = tipode(id.lexema)//array(10,integer)}
| +-id {id.lexema = "a"}
| +-a
+-[
+-E3 {E3.tipo = E2.tipo==pointer(t1) entonces t1 //integer}
| +-E2 {E2.tipo = tipode(id.lexema)//pointer(integer)}
| | +-id {id.lexema = "p"}
| | +-p
| +-^
+-]

TDS:[id,tipo]
[p:pointer(integer)]
[a:array(10,integer)]

EJERCICIO 6.5C
Asumiendo que existe
E -> E(E)
P -> D;S
S -> id := E
S -> if E then S1
S -> while E do S1
S -> S1;S2

P
+-D
| +-D {declare (id.lexema,T3.tipo)}
| | +-id {id.lexema="f"}
| | +-:
| | +-T3 {T3.tipo = (T1.tipo->T2.tipo)//(integer->boolean)
| | +-T1 {T1.tipo = integer}
| | | +-integer
| | +-'->'
| | +-T2 {T2.tipo = boolean}
| | +-boolean
| +-;
| +-D
| +-D {declare(id.lexema,T4.tipo)}
| | +-id {id.lexema = "i"}
| | +-:
| | +-T4 {T4.tipo = integer}
| | +-integer
| +-;
| +-D
| +-D
| | +-id {id.lexema="j"}
| | +-T5 {T5.tipo=ingeter}
| | +-integer
| +-;
| +-D {declare(id.lexema,T6.tipo)}
| +-id {id.lexema="k"}
| +-:
| +-T6 {T6.tipo=integer}
| +-integer
+-;
+-S6 {S6.tipo = E3.tipo==boolean entonces S5.tipo //vacio}
+-while
+-E3 {E3.tipo = E2.tipo==integer && E1.tipo=(integer->boolean) entonces boolean}
| +-E1 {E1.tipo = tipode(id.lexema)//(integer->boolean)}
| | +-id {id.lexema="f"}
| +-(
| +-E2 {E2.tipo=tipode(id.lexema)//integer}
| | +-id {id.lexema="i"}
| +-)
+-do
+-S5 {S5.tipo = S1.tipo == vacio && S4.tipo == vacio entonces vacio}
+-S1 {S1.tipo = tipode(id.lexema)== E4.tipo entonces vacio;}
| +-id {id.lexema="k"}
| +-:=
| +-E4 {E4.tipo=tipode(id.lexema)//integer}
| +-id {id.lexema="i"}
+-;
+-S4 {S4.tipo = S2.tipo == vacio && S3.tipo == vacio entonces vacio}
+-S2 {S2.tipo = tipode(id.lexema)== E7.tipo entonces vacio}
| +-id {id.lexema="i"}
| +-:=
| +-E7 {E7 = E5.tipo ==integer && E6.tipo ==integer entonces integer}
| +-E5 {E5.tipo = tipode(id.lexema)//integer}
| | +-id {id.lexema="j"}
| +-mod
| +-E6 {E6.tipo = tipode(id.lexema)//integer}
| +-id {id.lexema="i"}
+-;
+-S3 {S3.tipo = tipode(id.lexema)==E8.tipo entonces vacio}
+-id {id.lexema="j"}
+-:=
+-E8 {E8.tipo=tipode(id.lexema)//integer}
+-id {id.lexema="k"}

TDS:[id,tipo]
[f,integer->boolean]
[i,integer]
[j,integer]
[k,integer]

El primer disque compilador de mi existencia

2005-10-30T21:34:00.000-06:00

Primer experimento generando código, gran cosa no es, pero emociona... es como decir que estas construyendo un carro y ver juntas por primera vez las cuatro ruedas(pegadas al chasis, correctamente), aunque haga falta todo el resto, ya tienes una plataforma que se mueve...

Asi se siente poner en marcha un pequeno compilador de sumas para mips. bueno, spim... (ni es lo mismo ni es igual)

Eso me recuerda que cuando inicie mis estudios, mi papá me preguntó que como era que los ceros y unos se convertian en un programa, y como era que la computadora los hace funcionar.
Hasta ahora, cuatro años después podría decirle una respuesta...

Para iniciar, recuerdan el ejemplo minimal? pues, bien, utilicé el archivo minimal.lex, y modifiqué minimal.cup.

package Ejemplos;

import java_cup.runtime.*;
import java.util.LinkedList;

parser code {:
public static void main(String args[]) throws Exception {
new parser(new Yylex(System.in)).parse();
}
:}

action code {:

private boolean[] usoReg = new boolean[8];

private String getFreeReg(){
for(int i = 0; i < i =" (int)(reg.charAt(2)" nreg =" getFreeReg();" result =" new" reg =" nReg;" result =" new" reg =" T.reg;" nreg =" getFreeReg();" result =" new" reg =" nReg;" result =" new" reg =" F.reg;" nreg =" getFreeReg();" result =" new" reg =" nReg;" style="font-family:georgia;">La parte de la gramática es igual que el ejemplo en clase, salvo unas pequeñas modificaciones.
aca lo interesante es la funciopn para tomar un registro y para liberarlo. No son nada del otro mundo vdd?

Dado este código de cup, generando, compilando y corriendo, se abre la consola, donde hay que escribir la cadena de sumas y multiplicaciones, terminados con puntoycoma, aqui pueden ver el ejemplo de corrida:

----------------------------
2+3*8+6*9*5;
li $t0 , 2
li $t1 , 3
li $t2 , 8
mul $t3 , $t1 , $t2
#queda libre $t1(1
#queda libre $t2(2
add $t1 , $t0 , $t3
#queda libre $t0(0
#queda libre $t3(3
li $t0 , 6
li $t2 , 9
mul $t3 , $t0 , $t2
#queda libre $t0(0
#queda libre $t2(2
li $t0 , 5
mul $t2 , $t3 , $t0
#queda libre $t3(3
#queda libre $t0(0
add $t0 , $t1 , $t2
#queda libre $t1(1
#queda libre $t2(2
#se escribe el resultado
li $v0, 1
add $a0, $zero, $t0
syscall
terminamos?
------------------------ '
otro ejemplo:
------------------------
3*9*2*4*5;
li $t0 , 3
li $t1 , 9
mul $t2 , $t0 , $t1
#queda libre $t0(0
#queda libre $t1(1
li $t0 , 2
mul $t1 , $t2 , $t0
#queda libre $t2(2
#queda libre $t0(0
li $t0 , 4
mul $t2 , $t1 , $t0
#queda libre $t1(1
#queda libre $t0(0
li $t0 , 5
mul $t1 , $t2 , $t0
#queda libre $t2(2
#queda libre $t0(0
#se escribe el resultado
li $v0, 1
add $a0, $zero, $t1
syscall
#terminamos?

----------------------
Como es obvio, falta la parte de las directivas y todo ese rollo... por los momentos mis pruebas las hice mediante copy-paste. Con ver que el resultado correcto se desplegara en la consola, me bastaba.

Claro, que no salio a la primera, en varios intentos, mi codogo salia escrito con errores de sintaxis, pero eso es naturalmente debido a la falta de práctica con MIPS.

Una Hashtable con múltiples objetos bajo la misma llave

2005-10-30T21:11:00.000-06:00

En mi proyecto, la tabla de símbolos está implementada mediante una tabla hash que contiene objetos entre cuyos campos están el nombre y el ámbito. La llave de dichos objetos se calcula entonces concatenando el valor del ámbito, cuatro puntos (“::”) y el valor del nombre.

Esto tiene la ventaja de que rápidamente se puede averiguar si existe ya un identificador con un nombre dado en el ámbito especificado, pues basta con calcular la llave y preguntarle a la Hashtable mediante el método containsKey. La dificultad que esto me propuso, era el problema de cómo recuperar TODOS los identificadores dado un ámbito, i.e. dado el nombre de una función o procedimiento, recuperar tanto parámetros como variables locales.

Primero, y para no hacer un recorrido estilo Programación 1 en busca de todas las instancias cuyo campo ámbito correspondiera, quise averiguar si hay una forma de que la tabla hash pudiese mapear una sola llave a varios objetos. Aun no se si se puede, pero javadoc dice que “el nuevo valor asociado reemplaza al valor anterior”. Busqué dentro del mismo javadoc a ver si existe otra estructura capaz de hacer el trabajo; la búsqueda fue infructuosa. Ya sin ideas, pregunté a compañeros y profesores. La mayoría me sugiere que cree mi propia clase, y un compañero me sugirió que usara una tabla hash por ámbito en la cual guardase tablas hash por nombre.

Lo primero es: combinar esas dos sugerencias. Creo que funcionaría, pero me complicaría los procedimientos de inserción y búsqueda de símbolos, que ya está programada y probada.

Decidí hacer lo siguiente: 1) Mantener mi tabla de símbolos tal y como está hasta ahora. 2) Agregar una segunda tabla hash, donde las llaves son ámbitos y los valores son LinkedList que apuntan a los mismos objetos que están en la tabla original.

De esa forma, la lista de los identificadores pertenecientes a un ámbito está “siempre lista y servida para llevar”.

Ya realicé los primeros ensayos. La inserción en ambas tablas se hace sin problemas, y aunque para terminar de hacer útil esa segunda tabla de símbolos hace falta un par de adiciones, ya se ve que cumple los objetivos.

El principal uso que pretendo darle es principalmente para comprobar los tipos de los parámetros en las llamadas a funciones, Aunque aun no estoy 100% seguro de cómo hacer eso... jeje.

Assembler en MIPS

2005-10-25T00:20:00.000-06:00

Primero que nada, mis disculpas por la entrega tardía. La excusa la dejo a la imaginación.

Comentarios generales:

El laboratorio fue fácil de hacer, las dificultades, como siempre aparecen haciendo más interesante el rollo.

Instalé la versión que venia en el CD que encontré en el parqueo, eso no dio problemas.

Luego, copiar el codigo del ejemplo de suma, pues valla! esta vez copié bien!!!. La carga se hizo bien, probé y funcionó.

Hasta aquí todo bien, el problema fue que suspendi el laboratorio y lo retome hasta el lunes en la noche.

Para ser honestos, mejor ví algunos blogs de los compañeros, y lógico, mi codigo no salio tan diferente, asi que solo voy a relatar algunas cosas que por lo menos no estaban en los blogs que YO VI.

1. para ahorrarme el error de escribir mal $zero, aprendi a usar la y move. tambien escribo menos .

2. aprendi a usar jal, porque mi programa ejecutava en ciertas ocasiones "tanto el if como el else", entonces decidi usar jal para tirar la ejecucion hasta despues del "cuerpo del else".

3. Quise usar las cadenas directamente en la instruccion, sin usar cadn, pero no halle el modo, si es que existe.

4. No se como funciona el modo de ejecucion por pasos, ya que le coloco cualquier numero de pasos en la caja correspondiente pero no veo que pase nada, no veo que cambien los registros, asi que, me conformé con verlos mientras el programita "esperaba el entero"

Comentarios finales

El Assembler de MIPS es para mí {mucho}* más fácil que el de Intel. Con sólo ver el codigo de suma, sabía por donde "iba la cosa". Me dió por revisar uno de los viejos ejemplos de cuando cursé "Organizacion de Computadoras" o "Diseño Lógico Digital"(no recuerdo cual es cual, deberían llamarse las dos del mismo modo, con I y II como todas las demás), y no se que dice ahi. (asembler de intel...)

Hacerle las modificaciones al código no fue difícil, excepto por que si se comete un error el simulador no lo informa como solemos estar acustumbrados, y hay que rebuscar un poquito pero "eso se lima con el uso".

Una vez más, lamento lo escueto del contenido de la clase antes mencionada, ya que el asunto del ensamblador es sumamente interesante, no tanto a nivel de programaciónes sencillas, sino a nivel de análisis como en las llamadas de procedimientos(que no he visto en detalle pero se que estan en "el apendice", y habría sido macanudo tener una clase en hondureño al respecto. Eso lo digo porqeu siempre que busco algo en Internet , me pierdo y termino averiguando otra cosa que nada tiene relacionado con lo que incialmente buscaba.

Electivas?

2005-10-16T22:09:00.000-06:00

En respuetsta a la pregunta ¿Qué curso optativo me gustaría recibir en la carrera de Ingeniería de Sistemas y por qué?...
Se me hace una pregunta difícil, pues en lo personal creo en la diversificación del conocimiento como un arma sumamente poderosa, especialmente en un mundo globalizado, donde se requiere no solo de una amplia gama de conocimientos, sino también de la capacidad para relacionarlos en formas nuevas para lograr el avance, y sacar de su estancamiento a países como el nuestro.
Por otro lado, también creo en el autoaprendizaje, sobre todo como principal fuente de diversidad de conocimientos.
En ese sentido, es mi opinión, que un curso electivo debe tener una relación no obvia con la carrera, pero no puede en definitiva ser un tópico aislado totalmente. Creo que debe ser una tipo de conocimiento práctico relacionado con el desempeño real que un graduado de la carrera de Sistemas Computacionales de Unitec debería tener dentro del sector laboral-industrial hondureño.
Todo esto, para concluir, que me agradaría incuir como parte de mi formación en Unitec, una clase en la que se nos enseñe a formar parte de, y a dirigir grupos de personal multidisciplinario, y convertirlos en auténticos equipos de trabajo. No sé como podría llamarse una clase como esa, y si llegase a existir en Unitec, espero que no le pongan un nombre indecente ni demasiado "inflado".
Tal preferencia surge de la observación más inquietante que he realizado desde que formo parte del conjunto cuasimisterioso, elitista, todopoderoso de estudiantes de Sistemas, la tremenda incapacidad que tenemos "los de sistemas" para comunicarnos entre nosotros, y con "los demás"; y solemos decir "los demás en un tono casi despectivo, como si nadie más en el mundo tiene conocimientos específicos de SU carrera de los cuales la gran mayoría son ignorantes, lo cual porsupuesto, nos incluye también a "nosotros".
Esa forma elitista de ver el mundo de la cual pecamos la mayoría de los estudiantes de sistemas (para no mencionar a los docentes y profesionales del área) es una fuerte barrera que en muchos casos impide aprovechar de manera óptima el conocimiento y habilidades de las personas cuya preparación es distinta de la nusestra. Debo aclarar que no me refiero solamente a la preparación académica, pues "no hay mejor escuela que la experiencia", y de allí que en el mundo de los negocios haya triunfado tanto "analfabeta".
Existe una fuerte tendencia del alumno de sistemas de reinventar la rueda,especialmente a la hora de llevar a cabo proyectos que simulan software empresarial, donde "nos toca inventar como hacerlo" porque "no entendemos lo que nos ha dicho el cliente".
Es por eso que mi eleccion sería en definitiva, un curso en el cual se nos preparase la mente para aprender "como llevarnos con los demás" en el sentido productivo de la frase, porque, en conformidad con la idea de "profesionales capaces de desarrollar y transformar empresas", podría ser que sea la carrera de sistemas la más débil, porque a diferencia de Mercadotecnia, Publicidad o Turismo, de las cuales en casos hasta nos atrevemos a hecer burla, y a quienes se les ha enseñado por concepto a estudiar a la gente como fuente de negocios, a nosotros se nos ha enseñado a estudiar las ciencias de la computación en uno de los sentidos más mecanicistas, casi olvidando que el propósito de la máquina es el hombre, no al revés.
Digo todo esto, porque e las clases de la carrera en las que que habla de la gente, del cliente -que dicho sea de paso son pocas- , se trata al "usuario" como si se tratase de un ser disminuido en capacidades, y encontrando incluso textos formales que hacen referencia al usuario como si fuese un tonto de cuyas faltas es necesario protegerse, olvidando a veces por completo la naturaleza humana que caracteriza todas y cada una de nuestras obras.
En resumen, y luego de esta crítica que aseguro, está basada en mí mismo y en mis más cercanos compañeros, reitero que me gustaría que tratásemos en curso formal y bastante de cerca, la psicología, el comportamiento humano, la comunicación y las relaciones interpersonales, a fin de lograr el mejor provecho de las personas que han optado por una rama del conocimiento distinta, para saber como colaborar con ellos, para poder interactuar mejor con y como gerentes de empresas.
Y solo para sellar, y no quedar en contradicho con mi afirmación a cerca del autoaprendizaje, me permito recordar, que si bien esas ramas de conocimiento arriba mencionadas, pueden fácilmente buscarse y encontrarse en lecturas abundantes, son también áreas de conocimiento bastante extensas, y que un curso debe tener la intención de mostrarnos qué aprender, para no perder el norte.

Ejemplo de main

2005-09-25T12:15:00.000-06:00

public static void main(String args[]) throws Exception {
System.out.println("Bienvenido a Comodo");
FileReader fis = new FileReader("uno.pas"); // se construye el File reader
// una versión mas sofisticada no coloca fijo el nombre, sino que puede leerlo de std in
// o tomarlo del array de argumentos args[]
parser paspar = new parser(new Yylex(fis));
// el constructor de parser toma un Yylex, cuyo constructor toma el fileReader
paspar.parse(); // esta es la llamada importante.
// este codigo se puede colocar en parser code {: :} dentro de cup
// o dentro de otra clase que tenga acceso tanto a parser como a Yylex.
}

Otra aplicación típica para JFlex

2005-09-04T21:17:00.000-06:00

Soy uno solo

¿Quién no ha querido en ocasiones convertirse en varios a la vez? Esta semana no he podido avanzar con el complilador, tuve que entregarle mi tiempo a documentar un diseño que ya tengo un poco avanzado.

Pero siempre hay tiempo para "jugar" un poco y como tengo un programa pendiente, el cual ya varios amigos me han dicho que está interesante, un "commander" que reconoce comandos creados por el usuario para correr programas o abrir archivos específicos mediante pequeñas abreviaturas.

Una de las mejoras es naturalmente implentarle tecnología de compiladores a ese programa, para mejorar el reconocimiento de comandos.

La idea con ese programa es escribir lo menos posible, de modo que su uso acelere la productividad. Por lo tanto, una mejora sustancial, es que el programa detecte que comando llamar, con ver solamente el parámetro. Es decir, provéele solamente www.loquesea.tu, y el solo abrirá Iexplore, dile C:\Mis Polainas y automáticamente se abriria una ventana del Explorador de archivos, apuntando a esa carpeta.

Esto es muy sencillo de lograr, utilizando un analizador léxico.

Aqui les presento un ensayo, totalmente autónomo, realizado en JFLEX. Con Autónomo me refiero a que no utilicé absolutamente nada más que jflex.

El ensayo toma uno o varios archivos, o la entrada estandar, y reconoce ciertos tipos de cadenas comunes. Este ensayo podría ser útil también, para entender como es que Word convierte automáticament en Links, cuando uno escribe una direccione de correo, o de internet.

--------- empieza JFlex -------------

import java.io.*;

/**
* Class YyLex, creada mediante jFlex a partir de minimal. lex.
* @author Gerson Lara
* @URL http://www2.cs.tum.edu/projects/cup/minimal.tar.gz
*/
%%
%class Liner
%type int
%full
//%cup
%{

static void print(String s){ System.out.print(s); }
void sout(String s){ System.out.print(s + ": " + yytext() + "\n"); }

public static void main(String args[]) throws Exception {

print("Bienvenido a line detector\n");
System.out.println("Argumentos: " + args.length);
for(int i = 0; i < args.length; i++){
System.out.println("Leyendo desde archivo: " + args[i]);
FileReader fr = new FileReader(args[i]);
Liner cuente = new Liner(fr);
cuente.funcione();
}

if(args.length == 0){
System.out.println("Leyendo desde System.in");
Liner cuente = new Liner(System.in);
cuente.funcione();
}
}

public void funcione() throws Exception {
yylex();
print("\n");
}
%}
LETRA=[A-Za-z_~]
DIGITO=[0-9]
PUNTUAC=[!#?]
TRESD={DIGITO}({DIGITO}{DIGITO}?)?
NOMBRE={LETRA}+(" "{LETRA}+)*
%%
[\t\f\n|\r] { /* ignore white space*/ }
{LETRA}+"://"{LETRA}+("."{LETRA}+)*("/"({LETRA}+|"."|{PUNTUAC})+)* { sout("URL");}
{LETRA}+"."{LETRA}+("."{LETRA}+)* { sout("Direccion de internet");}
{LETRA}+@{LETRA}+"."{LETRA}+ { sout("Direccion de correo-e");}
{LETRA}: {sout("Unidad de disco");}
{LETRA}":"("\\"{NOMBRE}("."{NOMBRE})*)* { sout("Directorio");}
{LETRA}+ { sout("Palabra");}
{TRESD}"."{TRESD}"."{TRESD}"."{TRESD} {sout("Direccion IP");}
<> { return 0;}
. { sout("Expresion no reconocida"); }
----------- termina JFlex --------------

Aqui un par de ejemplos de corrida. El primero fue lanzado directamente desde el IDE, y el segundo fue utilizando linea de comandos y alimentándolo con dos archivos de texto.

---------- empiezan ejemplos ------------
Bienvenido a line detector
Argumentos: 0
Leyendo desde System.in
www.unitec.edu
Direccion de internet: www.unitec.edu
efutch@gmail.com
Direccion de correo-e: efutch@gmail.com
dir
Palabra: dir
c:
Unidad de disco: c:
c:\cmpl
Directorio: c:\cmpl
192.167.0.1
Direccion IP: 192.167.0.1
^Z

Press any key to continue...

-------------------------------------------------------------
Microsoft Windows XP [Version 5.1.2600]
(C) Copyright 1985-2001 Microsoft Corp.

C:\Program Files\Comendador>cd C:\cmpl\src\WrdCnt\Liner

C:\cmpl\src\WrdCnt\Liner>java Liner correos.txt rev.txt
Bienvenido a line detector
Argumentos: 2
Leyendo desde archivo: correos.txt
Direccion de correo-e: glaraf@unitec.edu
Direccion de correo-e: iguana@tierra.mia

Leyendo desde archivo: rev.txt
Direccion de internet: www.huevos.revueltos.com
Directorio: C:\yuca

C:\cmpl\src\WrdCnt\Liner>
---------- terminan ejemplos ------------

Espero que con esto se les ocurran más ideas de lo que pueden hacer con JFlex y similares. A mi se me ocurre hacer un "Find & Replace" más poderoso que los normales. Creo que ese será el siguiente "Juguete".

Integración Total y los Cuarenta Tokens

2005-08-28T22:53:00.000-06:00

En la recién pasada semana tuvimos la oportunidad de trabajar en grupo, con lo cual nos compartimos algunas ideas, y, aunque ya se dijo que no hay que perder mucho tiempo con el IDE, sucede ser que tengo esa manía.
Entre otras actividades no muy productivas relacionadas con el compilador, comento que es bastante cómodo tener sintaxis coloreada en los archivos de cup y flex. En jCreator 2.00 es bastante fácil, pues entre las configuraciones del editor, uno puede escoger bajo el nodo Editor/Default, un archivo de sintaxis.
Debo decir que me resulto muy fácil crear un nuevo archivo.syn para la versión 2.00, que usa un simple archivo de texto, no obstante la versión 3.50 de jCreator, usa un archivo en formato xml, el cual no quise indagar.
El siguiente paso sería escoger que colores desea usar.
Por alguna razón insisto bastante con los colores, siempre paso un tiempo considerable con ello, como dije antes, esa es [una de mis tantas] manía[s].

Integración Total

Muchos me han preguntado como generar el Javadoc usando jCreator. Ignoro como se hace en otras versiones, pero la versión 2.00 no tiene el comando a la vista entre los menús.
La idea que me vino a la mente, no es osa del otro mundo: Si configuré dos herramientas para generar código, como fue el caso de los archivos.bat que mencioné en el blog anterior, ¿Cuál es la diferencia con Javadoc? Sólo dos: No se usa un .bat, sino un .exe y no se genera código de java, sino de HTML.
Asi es, los pasos son los mismos, solo hay que fijarse un poco con los comandos:
primero, al elegir el nuevo programa, dirigirse a la carpeta donde estan los programas de la JVM, en mi caso esto era:
C:\j2sdk1.4.2_04\bin
Después al configurar la herramienta, usar los siguientes campos:
Commands = C:\j2sdk1.4.2_04\bin\javadoc.exe -d doc -private
Arguments = $[JavaFiles]
Initial Directory = $[PrjDir]

La opción -d permite especificar un directorio de salida, en mi caso -d doc usará una carpeta llamada doc, la cual creé previamente en la carpeta del proyecto ($[PrjDir]), esto para evitar que los elementos del Javadoc se mezclen y/o confundan con mis archivos de código fuente.
La opción -private hace que se incluyan las clases privadas. Sin esta opción, no me documentaba la clase Yylex. (Agradecemos la colaboración de Osman Santos en la averiguación de este pequeño detalle)

Para el campo Arguments, recomiendo utilizar el boton que despliega el menu, y utilizar la opción Project Java Files, y en Initial Directory, la opción Project Directory.

Los Cuarenta Tokens

Lo admito: ¡me encanta jFlex!
Comparándolo con los recuerdos de mi experiencia con ANTLR, puedo afirmar que me siento mucho más confiado con JFLEX.
Aunque al principio no me gustó la documentación, hay que reconocer, que para todo se requiere paciencia, asi que puse esta trillada frase en práctica y leí una buena porción.
Encontré de gran ayuda el ejemplo en el cual especifican parte de la sintaxis de Java, del cual tomé varias ideas, en especial para reconocer strings y secuencias de escape. En realidad no estoy muy seguro de si aplican las secuencias de escape en Pascal, pero por motivos de práctica, intenté hacer que funcionara como en C.

En general, para el lexer, mi estrategia se basa en dos ideas:

1) Los errores deben estar bajo mi control, no bajo el de Yylex, asi los puedo reportar de manera conveniente. y

2) Hay que hacer reglas para aceptar tokens correctos, y reglas para capturar errores.

Lo segundo se debe a algo muy sencillo: si el token está correcto, no hay problema, Yylex lo reconocerá y lo retornará al parser. Pero si el token está mal escrito, Yylex nos dará un extenso y casi ininteligible mensaje de error, ya que el error ocurirá internamente en Yylex, no el el código fuente que estemos analizando.
Además: en algunos puntos es más fácil (con JFlex) hacer las reglas para capturar errores, que hacer expresiones regulares perfectas.
Por ejemplo para los comentarios: es más facil irse a un estado aparte, y tirar el error de anidamiento si encontramos una apertura de comentario, que hecer la expresión regular que admita comentarios sin anidamiento. Aparte, si la ER no reconoce comentarios con anidamiento, el error "lo reportará Yylex", en lugar de "reportarlo yo"

El huevo y la gallina

Para probar el Lexer usé esto:
-------- empieza código -------------
package Jahaz;

import java_cup.runtime.*;
import java.io.*;

/**
Clas Comodo, calache para probar el Yylex solo.
@autor Gerson Lara

*/

public class Comodo{
public static void main(String args[]) throws Exception {
System.out.println("Bienvenido a Comodo");
//Yylex alex = new Yylex(System.in);
FileReader fis = new FileReader("hola.pas");
Yylex alex = new Yylex(fis);
int a = 0;
while(a < 1000){
alex.next_token();
//System.out.print("");
a++;
}
}
}
---------- fin de código --------------

Con esto puedo especificar un archivo en el cual coloco una serie de Tokens, que no tienen porque estar en orden gramatical, unos de ellos bien escritos, pero la mayoria de ellos con errores, así me cercioro de que mi lexer captura los errores y los reporta adecuadamente.

Si ese era el huevo, ahora la gallina:
para que el lexer pueda retornar todos los tipos de token, hay que declararlos como terminales en el archivo de CUP y generar y compilar ese codigo, para que la clase sym esté disponible.

Notas sobre los nombres

Mi compilador se llama Comodo ( no es Cómodo, no lleva el acento en la primera o) y como se lo han de imaginar, se debe al Dragón de Comodo, por ser un dragón real que existe hoy en dia.

El lexer se llama Alex por que es un Analizador LEXico
Este compilador será algo así como "El Show de Alex, Parseo y Semita"
Parseo suena como a Perseo, algo griego, pero no se qué. Y Semita por SEMántico.

Si no les da risa, lo entiendo, de por sí, es sabido que no soy bueno para los chistes, y peor a la hora de este post.

Hasta la próxima, ¡y no dejen de buscar al IDEal!!!

jFlex & CUP con jCreator

2005-08-22T15:35:00.000-06:00

Usando: jCreator 2.00 LE Build 008

Debido a que ya algunos perdimos bastante tiempo con Eclipse, aquí coloco mi forma de configurar jCreator para trabajar con jFlex y CUP

Notras Previas:

Los pasos que aquí detallo son una muestra particular de la manera en que yo realicé la prueba. Este documento fue escrito paralelamente con la realización de la prueba, intentando el máximo de detalle.

Cualquier consulta me la pueden hacer a gerson.lara con la arroba ,gmail el punto y el com, o a mi Telefono de casa(si lo tienen).

OS: Windows XP home en Inglés, versión 2002 con Service pack 2 (instalado desde windows update)

JVM:

C: java -version

java version "1.4.2_04"

Java(TM) 2 Runtime Environment, Standard Edition (build 1.4.2_04-b05)

Java HotSpot(TM) Client VM (build 1.4.2_04-b05, mixed mode)

Computadora: HP con procesador Intel Celeron.

Observación: en las líneas siguientes hago referencia al directorio cmpl, éste es el directorio Complilers_home, o cualquier otro en el cual haya extraído los archivos de jFlex y CUP, y realizado los primeros pasos del Laboratorio #1

Crear El directorio C:\cmpl\src
Abrir sesión en jCreator
Ir a File/New... ,

Seleccione Workspace/Empty workspace,
Workspace Name = Inicio
Location = C:\cmpl\src

El IDE crea una carpeta nueva: C:\cmpl\src\Inicio

Ir a File/New...

Seleccione Projects/Empty Project
Project name = tDragon,
El campo Location debe apuntar a la carpeta del workspace
Asegúrese que esta seleccionada la opción “Add to Current Workspace”

El IDE crea una carpeta nueva: C:\cmpl\src\Inicio\tDragon

Ir a File/New...

Seleccione Files/Text File
Filename = tDragon.lex.
Deje el campo Location como está,
La opción Add to Project en true, y en el combo de abajo el proyecto tDragon (por ahora el único)

Escriba la especificación léxica (Nota: yo pegué el contenido de minimal.lex)
Repita pasos similares para el archivo punto-cup.
Configuración de User Tools parte I: jFlex

Ubique el archivo jflex.bat, (en mi caso: C:\cmpl\JFlex\bin\jflex.bat), vea más abajo el contenido de este archivo.
Ir al menú Configure/Options, elija Tools (ojo, ¡no JDK Tools!). En el lado derecho presione NEW / Program y a continuación diríjase a la ubicación del archivo jflex.bat y selecciónelo.
Aparecerá en el TreeView un nuevo hijo de Tools con el nombre jFlex, selecciónelo para configurar la nueva herramienta.
En el campo commands debe aparecer de nuevo la ruta y nombre del archivo jflex.bat. Si no es su caso, presione el botón rotulado con los tres puntos y repita la selección del archivo.
En el campo Arguments elija, mediante el menú que aparece al presionar el botón rotulado con un triángulo, el parámetro “File name”.
De manera similar Elija “Project Directory” en el campo Initial Directory
En el recuadro inferior “Tool Options” elija según su conveniencia, recomiendo usar “Save all documents first”
Si no tiene visible la Barra de Herramientas “Tools”, actívelo en View/Toolbars/Tools
Ahora una de los botones con icono en forma de llave de tuerca corresponde con jFlex, si ésta era la primera herramienta que configura, será la primera llave.
Asegúrese de que el editor tiene activo el documento tDragon.lex y pruebe la primera herramienta.
Revise el directorio del Proyecto (C:\cmpl\src\Inicio\tDragon\), debe haber aparecido el archivo Yylex.java, agréguelo al proyecto. (Menú Project/Add files)

Configuración de User Tools parte II: Java_cup

Será necesario crear un nuevo archivo punto-bat en C:\cmpl. (en mi caso C:\cmpl\jcup.bat). Vea más abajo el contenido de este archivo.
Configure la segunda herramienta igual que en el caso anterior, seleccionando jcup.bat (o su equivalente), los argumentos y directorio inicial, son los mismos.
Asegúrese de que el editor tiene activo el documento tDragon.cup y pruebe la segunda herramienta.
Revise nuevamente el directorio del proyecto y compruebe que existen lso nuevos archivos parser.java y sym.java. Agréguelos al aproyecto.

Diríjase a Project/Project Settings,

Vaya a Required Libraries y presione NEW.
Presione Add/Package, y Elija el archivo jflex.jar, que se encuentra en C:\cmpl\JFlex\lib\, en el campo name coloque jFlexJar
Cuando regrese al diálogo Project Settings, asegúrese que la nueva librería está seleccionada(Marcada con Check)

Compile el Proyecto (F7) y córralo(F5);

En mi caso, me compilo sin problemas y me corrío lo mismo que en el laboratorio en la parte que se hace en command Line. Aún así, salen errores al compilar los archivos individuales desde jCreator, hay que compilar todo el proyecto.

Contenido de los archivos punto-bat

----- inicio de batch: jFlex.bat ---------

@echo off

REM Edite los path JFLEX_HOME y JAVA_HOME para sus necesidades

REM (No agregue backslashes al final de los paths)

rem set JFLEX_HOME=C:\Compiladores\JFlex

REM only needed for JDK 1.1.x:

rem set JAVA_HOME="C:\Program Files\Java\j2sdk1.4.2"

REM -------------------------------------------------------------------

set CLPATH=C:\j2sdk1.4.2_04\bin\lib\classes.zip;C:\cmpl\JFlex\lib\JFlex.jar

REM for JDK 1.2

java -Xmx128m -jar C:\cmpl\JFlex\lib\JFlex.jar %1 %2 %3 %4 %5 %6 %7 %8 %9

---------- fin de batch ------------

---- inicio de batch: jcup.bat ---------

REM @echo off

REM Creado por Gerson Lara

rem Con el proposito de correr java_cup

REM Usando la misma idea que con jFlex.bat

REM -------------------------------------------------------------------

set CMPL_HOME=C:\cmpl

set JAVA_HOME=C:\j2sdk1.4.2_04\bin

set CLASSPATH=%CMPL_HOME%\Java_cup;%CLASSPATH%

java java_cup.Main %1 %2 %3 %4 %5 %6 %7 %8 %9

---------- fin de batch ------------

Un lexer hecho a mano

2005-08-14T23:49:00.000-06:00

EL proyecto de “Turbo Dragon” está en peligro de extinción.

Aún sigo sin poder conectar efectivamente las herramientas de generación de código con Eclipse. La situación resulta bastante frustrante, para una estudiante de la carrera donde “todo se puede”. Es por esto que he tomado una decisión, de ninguna manera me voy a dejar “ECLIPSAR” por un IDE superconfigurable, así que si mr. E. sigue rebelde, doña Consola, que no me defrauda, me será más que suficiente para hacer un compilador.

En efecto, no he tenido problemas modificando los meta código-fuentes y construyendo mis ensayos desde la línea de comandos.

Convencerme que no soy yo el problema.

Si bien, lo admito, tiene que haber “una forma”, no la encuentro, así que con el propósito de convencerme que por lo menos aún soy capaz de pensar (bien), he realizado un brevísimo ensayo, en el cual construyo un lexer, casi totalmente a mano.

Pido disculpas por el “gol publicitario” pues s’e que muchos de los colegas no son precisamente aficionados a Microsoft®, pero mis auxiliares en este ensayo han sido los tan odiados como necesarios Word® y Excell®.

El ensayo está basado en el último ejemplo visto en clase(hasta ahora) de un autómata para reconocer operadores relacionales.

He construido mi propio autómata para reconocer operadores aritméticos, enteros positivos y paréntesis.

Recuerden que este es un lexer, así que no sabe NADA a cerca del orden en que estos elementos deben aparecer.

La primera fase, fue pensar los tipos de token a usar:

num = digito+

oper = [+-*/]

lpar = ‘(’

rpar = ‘)’

donde:

digito = [0123456789]

Con esto en mano (cabeza y necesariamente papel), procedí a crear el autómata. Importante notar, que el autómata debe ser determinista, ya que para este ensayo no disponía de ninguna herramienta para reducir un grafo cualquiera a DFA.

“Por favor disculpen lo burdo de este modelo, no tuve tiempo de hacerlo a escala” –Dr. Emmet Brown, Volver al Futuro.

Recuerden que un asterisco significa que se devuelve un caracter al input.

En este caso, el retorno de caracteres al input no parece congruente, lastimosamente, esto se debe a un detalle de la implementación, ya que mi autómata consume un caracter del input imediatamente que “llega” a un estado, para luego tomar la decisión a cerca de la siguiente transición. En este caso, supongamos que viene un ‘)’, el estado cero lee un caracter, luego internamente se da cuenta qué es y toma la transición al estado cuatro.

el estado cuatro lee inmediatamente un caracter, antes de saber que hará con él.

Pregunta clave en todo esto

¿Cómo programar el autómata?

Lo que procede es crear una tabla similar a la siguiente:

Estado/Simbolo

(

)

' '

TOKEN

t,6

t,5

t,4

t,1

t,0

NINGUNO

t,1

t,2

r,*

NUMERO

OPER

RPAR

LPAR

Donde cada estado puede tomar una transición a un estado (t,4 significa transición al estado cuatro), o puede retornar un token. Si hay un asterisco significa devolver un caracter al input.

Noten que cada estado puede retornar como máximo un tipo de token, si aplica(estados finales). una tercera posibilidad, es que se dé un error, como en la casilla (0,$), (estado cero, símbolo $), que en este caso significa que en el estado cero, cualquier caracter que no sea [()+-*/0123456789] ó SPACE será rechazado.

Cada vez que el autómata alcanza un e. final, regresa al estado cero.

La tabla anterior la programé como un arreglo bidimensional de casillas especialmente diseñadas (struct) que contienen un parámetro para saber si se trata de una transición, un retorno, o un error, el estado siguiente, en caso de transición, y si debe o no hacer unget().

El arreglo lo llené a mano, pero para ello me auxilié de Word, Excel, y muchos “find & replace”, con lo que generé un lote de asignaciones que completan la tabla.

Para ver el auxilio en Excel, siga este enlace, vea la Hoja 2.

La idea de cómo trabaja el Autómata ya programado, finalmente, es la siguiente:

1) Se inicia en el estado cero.

2) Se lee un caracter del input

3) se evalúa la casilla correspondiente al caracter para el estado actual.

3.1) si hay que hacer unget() se hace

3.2) Se decide que sigue:

3.2.1) Si es transición, se cambia de estado

3.2.2) Si es retorno, se retorna el token correspondiente al estado(considere la última columna de la tabla como un arreglo que contiene el tipo de retorno para cada estado.

3.2.3) Si es error, se reporta.

Estos pasos se toman en un ciclo hasta que se consuma la totalidad del input.

Nota: en este ensayo, el símbolo $ significa “desconocido” cualquier letra no reconocida en las primeras columnas de la tabla, mapean a $ para efectos de escoger la casilla a tomar en cuenta.

Pueden seguir este enlace para ver el código fuente.

Puede compilar este código en un compilador de C/C++.

Yo utilicé Dev-C++ 4.01.

Para probarlo proporcione el input que conste de: Paréntesis, operadores [+-*/] y enteros positivos: [0-9]+.

La salida es una simulación de un stream de tokens, similar a lo que constituye el output de un lexer(input de un parser). Recuerde que el Lexer no sabe nada a cerca del orden de los tokens.

Lo importante de este ensayo:

Conclusiones.

Fue relativamente fácil realizar este ensayo, tomó aproximadamente 2 horas, pero esto se debe a lo limitado del input para el cual fue diseñado, cuatro tipos de tokens. Un lexer para muchos más tipos, consume más tiempo.

El autómata ha de hacerse a mano(cerebralmente), y reducirse a determinista, o pensarse determinista desde el principio. y luego traducirlo a la tabla.

Una vez resuelto el problema de cómo llenar la tabla(en el código), la programación del autómata es sencilla, toma poco tiempo, y es constante, es decir, un cambio en el léxico, sólo requiere un cambio a la tabla, ya que el algoritmo para recorrer el grafo es siempre el mismo.

La modificación de esa tabla, sin embargo, es muy delicada.

Otra observación que considero muy importante, es el hecho de que las expresiones regulares que definen los tipos de palabra, finalmente quedan en la tabla( representación en código fuente del lexer para el autómata). de donde es mucho más difícil leerlas de regreso, por lo cual, no se puede entender que tipo de tokens lee el lexer con solo ver el código.

Finalmente, Las tablas de análisis léxico para un lenguaje real, suelen ser muy grandes para manejarlas fácilmente, aún en Excel.

En resumen, existe una razón por la cual se ha creado la cantidad tan extensa de generadores de analizadores léxicos, la complejidad es alta, pero rutinaria. Recuerde el algoritmo para reducir un Autómata No Determinista a uno Determinista.

Una aproximación básica a la creación de un “creador de lexers” comprendería la programación necesaria para leer las expresiones regulares que definen los tipos de token, y traducirlos a la tabla final, pasando por el autómata determinista, a lo cual, habrá solamente que adosarle el código del algoritmo para recorrer el autómata y las funcionalidades para recuperar los tokens desde un parser u otro programa.

Notas

La tabla que presento aquí, es parte de un tópico que se trata más adelante en el curso, sin embargo, debo aclarar que la terminología y técnicas usadas no son las mismas que en el Libro principal del curso, ya que adapté algunas partes para facilitarme la realización en corto tiempo. También el llamar Transición o Retorno a las casillas de la tabla, como más adelante se verá, es en realidad lo que se conoce como “Shift/Reduce”.

Reporte de Laboratorio Sección C:

2005-08-08T09:03:00.000-06:00

Reporte de Laboratorio Sección C:

Creación de un proyecto básico que incluya jFlex y CUP

Primero: Pegar Eclipse con jFlex

Este primer paso se logró configurando como Builder el archivo por lotes que se encuentra en

C:\cmpl\JFlex\bin\jflex.bat

especificando como directorio de trabajo:

${workspace_loc:/jFlexPrueba}

que es el directorio del proyecto creado en Eclipse, y finalmente, dando como argumento el nombre del archivo léxico:

${resource_name:/jFlexPrueba/experimental.lex}

Notas: Esto después de muchos intentos, ya que las instrucciones mencionan “como tipo External Tool”, tipo que no encontré, solamente vi disponibles «Ant Build» y «Program»

Inicialmente intenté con «Ant Build». “Ahí fue donde la mula botó a Genaro”, ya que me vi nuevamente ante una avalancha de configuraciones y parámetros...

Después recordé que para ejecutar jFlex hay dos opciones: una que implica el .jar, y otra que se hace desde el .bat. De modo que eliminé ese builder y agregué otro, esta vez de tipo «Program».

Utilicé primeramente el archivo .bat sin argumentos, y tuve que lidiar con el cuadro de diálogo de jFlex cada vez que a Eclipse se le ocurría hacer un Build. Por eso me demoré lo menos posible en colocarlos argumentos que indiqué al principio.

Observaciones uno

Una vez trazada la línea primera, logré hacer que Eclipse genere a Yylex.java, al examinar el código generado pude constatar que no difiere notablemente (al ojo humano) del que se generó en la parte anterior de la práctica, ya que experimental.lex es en realidad el mismo que minimal.lex.

Segundo: Pegar java_cup con Eclipse

De inicio, java_cup no tiene un .bat o un .jar entre sus directorios, sólo una cantidad considerablemente grande de archivos fuente, por lo cual intenté agregando el directorio de los mismos al « Build Path », sin resultados.

Luego, intenté implementar el mismo enfoque, crear un .bat que realizara la ejecución de java_cup, hasta el momento, sin resultados.

Otros Comentarios sobre el Laboratorio

2005-08-07T23:55:00.000-06:00

Primeramente debo aclarar, éste laboratorio fue mucho más interesante que el relacionado con ANTLR en el semestre pasado

Antes que lo olvide... aquí esta la versión en word del post anterior.

Aunque aun quedé un tanto confundido porque algunos de los problemas “se arreglaron solos” (Las computadoras a veces parecen no deterministas), fue un reto el tener que luchar contra herramientas desconocidas, lo cual no sucedió con ANTLR.

Hubo muchas dudas en lo referente a las líneas de comandos, ya que en comunicaciones entre compañeros, esas eran las preguntas más frecuentes.

Lo más extraño que maquinas muy similares, con la misma versión de JVM, sistema Operativo, Service Pack, etc. En unas funciona, y en otras no.

A mi me parece un MITO esa portabilidad que predica java, porque de una versión a la siguiente de la JVM hay que cambiar el código o hacer algún arreglo. Y ya entre plataformas distintas... no digamos.

Por cierto, en el post anterior hay una línea que dice:

La descarga y/o copia de los archivos requeridos se realizó son problemas.

Debe leerse:

La descarga y/o copia de los archivos requeridos se realizó sin problemas.

“Otro desafortunado efecto del hambre”

Debo agregar, que por mucho que me haya gustado el laboratorio, sentí muy confusas las instrucciones, y creo que no hablo (escribo) sólo por mí, ya que muchos compañeros me llamaron, preguntando...

La documentación de jFlex también me pareció confusa, [ y extensa ]. Una compañera utilizó el término “blurry”. En rosado y todo!!! (si alguien me lo traduce...)

En fin... el uso de los Paths en este laboratorio resultó algo inesperadamente dificultoso. Creo que el problema se debió a que no se captaba el concepto general de lo que se estaba haciendo con los .bat.

De hecho, uno de los compañeros, terminó escribiendo a mando los paths directamente en la consola, ya que los .bat no le resultaron.

En mi caso, quise elaborar un .bat para regenerar en un solo paso todos los archivos, tan sencillo como esto:

------------------------------

jflex minimal.lex

java java_cup.Main minimal.cup

javac -d . parser.java sym.java Yylex.java

----------------------------

Pero al parecer, las dos últimas líneas se metían como parámetros del primer programa, por lo cual sólo éste de ejecutaba, así que tuve que optar por aprovechar el buffer de instrucciones recientes del CMD.exe. (la tecla de flecha hacia arriba).

Al fin y al cabo... el que persevera alcanza, y ¡caballo que alcanza, gana!

Laboratorio 1

2005-08-07T23:50:00.000-06:00

A: Instalación del entorno Eclipse

1) Instalar en la carpeta c:\Eclipse

No hay observaciones relevantes.

2) Ejecución por primera vez

No hay observaciones relevantes.

3) Familiarizarse con los menús

Los menús de eclipse son muy diferentes a los de otros IDEs que he utilizado, por lo cual, familiarizarse no es una tarea trivial. Sin embargo creo que un poco de dedicación y práctica lo resuelven.

B: Creación de un proyecto Java

El nuevo proyecto fue creado, compilado y ejecutado sin observaciones relevantes.

C: instalación básica de jFlex y CUP

La descarga y/o copia de los archivos requeridos se realizó son problemas.

Sin embargo se encontró dificultades más adelante.

La primera observación es que en el .bat que se encuentra entre los binarios de jFlex existia un error en dos de los path, a los cuales les hacia falta una sub cadena “\lib” para funcionar correctamente. La corrección se hizo luego de notar que la ruta especificada no correspondía con la estructura de directorios creada por la extracción de los archivos de jFlex.

Luego de esto, la compilación de los archivos de jFlex & CUP, se realizó en una sola sesión, sin observaciones relevantes. Seguidamente la creación del código autogenerado al procesar los archivos minimal.lex & minimal.cup también se realizó de manera satisfactoria al primer intento, notando los avisos de cada programa respecto a los autómatas creados, estados, etc.; la subsiguiente re-generación en cada cambio realizado al archivo .lex se realizó igualmente en forma satisfactoria encada intento.

Más adelante, al compilar juntos los archivos Autogenerados, no se reporta ningún error.

La sección que más problemas causó, fue el intento de correr el resultado de la compilación antes mencionada, la cual siguió siendo problemática aún después de considerar las erratas respecto a la línea de comandos. En este caso la perseverancia, y el intento repetido lograron finalmente sacar a flote el Example.parser.

Ver la sesión del CMD.exe

En la Etapa concerniente a la limitación de los números menores que 64, la opción fue colocar el siguiente código:

{ if( Integer.parseInt(yytext()) >= 64 ){System.out.println("Numero demasiado grande: " + yytext());}

Esto como es de esperar, en la especificación para los tokens de tipo number.

Aunque esta era desde un principio la idea, tuve problemas al intentarla, pero, todos ellos se debían a la falta de práctica con java. Finalmente recordé que existe el .parseInt y con eso bastó.

Si están interesados en ver mis errores: CMD.exe

Podrán notar también, hacia el final del texto, que está hecha la modificación para que el resultado sea desplegado al presionar <>. Lo notarán en que no hay un punto y coma después de la expresión.

Esta solución, a mi parecer, debía hacerse en el parser, pero en el afán de seguir las instrucciones, se me ocurrió la idea más sencilla:

Convertir esto:

";" { return new Symbol(sym.SEMI); }

en esto:

"\n" { return new Symbol(sym.SEMI); }

Funciona, es todo lo que puedo decir.

Versión final de minimal.lex

Traba-doc

La herramienta javadoc... no me puedo quejar. ¿o si?

Leí el contenido de esta página. Hice mis intentos, y funcionó...

Con un archivo sí, y con otro no ( ¡oh, tronó! ).

Y pues bueno, luchando por tratar de entender cual fue la diferencia... si hice copy-paste, perdí mi tiempo.

Hice varios intentos, desde Eclipse, desde jCreator, y desde el CMD.exe. Siempre o mismo.

El archivo test.java, utilizado en la parte inicial del laboratorio si pudo ser documentado, al menos, se pudo comprobar que javadoc funciona.

Sin embargo, para el caso de minimal.lex, no se tuvo éxito. Incluso modificando directamente el archivo generado Yylex.java, no se obtuvo resultados satisfactorios.

Aquí muestro el último intento, desde la consola CMD.exe.

Pueden notar como el primer archivo funciona bien, pero el segundo... no.

En cuanto a la parte referente a Trabajar conjuntamente con Eclipse, jFlex, y CUP, aquí es donde entra una excusa en escena. Esto, lastimosamente, quedará para después.

Comentarios Finales.

Me sigo quejando a cerca de Eclipse. Por alguna razón que desconozco, no logro familiarizarme con este IDE. En comparación con jCreator, al cual le logro configurar más rápidamente. Debo hacer notar, que ninguno de los tres IDEs he usado por mucho tiempo, mi experiencia con java es realmente escasa.( Los Tres Amigos: Eclipse, NetBeans, jCreator ).

En cuanto a javadoc, me parece realmente interesante. Me dan ganas de probar que pasa si le pongo a trabajar con mis archivos de C++.

Los generadores de código: No tuve mucha oportunidad de tratar con ellos, pero pude notar que el código que generan no es tan claro como el de ANTLR.

¿Ingeniero en Sistemas? ¿Qué es eso?

2005-07-22T15:20:00.000-06:00

Pregunta filosófica, ¿Que es para mí un ingeniero en sistemas?

Primero intento contestar: ¿Que es para mí un ingeniero?

Bien intentando una definicion "estilo diccionario", un ingeniero es una persona capaz de analizar problemas y proponer, diseñar, implementar y mejorar soluciones apropiadas a esos problemas.

Como solía decir un proferor en mi colegio: "Muchachos, ustedes han de ser 'solucionólogos', no 'problemóloos'"

Recordemos la etimología de logos: estudiar.

Queda claro entonces el mensaje que quería transmitir el profesor, que yo traduzco de esta manera:
- Hay que perder más tiempo pensando en la solucion que en el problema. (Para que te quede más tiempo para llevar a cabo la solucion)

Esa es la idea que tengo de un "Ingeniero", pero a esto le debo agregar la idea que proviene de la similitud con la palabra "Ingenio", es decir que ese solucionólogo debe, en más de una ocasión, crear una nueva solución., porque lo más seguro es que ese problema no haya sido resuelto antes, y si lo fue, seguro no todas las condiciones eran iguales, por lo que en todo caso, hay que "ingeniar" la manera de que una solución que se ha usado antes, funcione ahora.

Claro ejemplo encuentro en la contruccion de un puente; contruir un puente ya se ha hecho, pero ¿que tal construir un puente en un lugar específico? El terreno no será igual, ni la longitud, o la altura, lo que hay debajo... etc.

La labor de un ingeniero empieza de hecho, desde que surge el problema: "Hay que ir de aqui para allá", uego viene el análisis: ¿sirve un puente, o un simple relleno, o mejor pasamos por otro lado? Y asi continuamos... hasta encontrar el mejor modo, luego diseñar y llevar a cabo la Solución.

Bien, la pregunta original era ¿Que es para mí un ingeniero en sistemas?.

Pues todo lo anterior, con la peculiaridad de que las soluciones que el/ella debe realizar, son de naturaleza computacional, y por lo general, implican una o más computadoras de algún tipo (lo más seguro es que trabajando en conjunto, interconectadas, etc.)

De nuevo: Un ingeniero es una persona capaz de analizar problemas y proponer, diseñar, implementar y mejorar soluciones apropiadas a esos problemas.

Creo que la parte más importante es "soluciones apropiadas", porque como decía otro de mis profesores "Los recursos son escasos". No podemos gastar más que lo que vamos a resolver, ¿o acaso...?

Y algo más que creo que debo recalcar es "una persona capaz", porque un título, un cartón o un documento, poco a nada importan si a la hora del té, la persona no es capaz. Esto, haciendo énfasis en que la "escolaridad" no le hace a uno ingeniero, (Solo le pone el prefijo al Nombre), por eso creo que un señor que conozco, que es jefe de un taller donde hacen "de todo" es más ingeniero que uno que solo aplica fórmulas... pero, para polemicas no estamos.

INGENIERIA: Ciencia y arte de aplicar lo conocimientos científicos a la invención, perfeccionamiento o utilización de la técica industrial e todas sus facetas. [Segun el diccionario]

Pro cierto, existe la palabra Ingeniatura,y tambien hubo un señor llmado José de Ingenieros.

Probando desde el correo

2005-07-22T15:15:00.000-06:00

Hola de nuevo!
Este blog haia estado abandonado... claro, lo escribia solamente por cuestiones de Compiladores !, y dado que la fallé, dejé de escribir.

Estoy en el segundo round, decidido a no volver a fallar. Claro, esta vez espero no tener otra clase que me robe 20 horas al dia.

Por cierto, esta publicacion la estoy haciendo via correo, es decir, que los del blogger proveen una dirección de correo que al enviar algo, resulta en un post.

Vamos a ver si es cierto

Un mar de configuraciones

2005-02-27T20:18:00.000-06:00

Ates: link a la version en MSWord de este blog:
http://www.geocities.com/jahazhn/cmpl/un_mar_de_configuraciones.doc

La plataforma eclipse puede ser un poco confusa. Son muy agradables toda la gama de posibilidades y facilidades que posee, sin embargo, por ser un IDE muy apartado de lo común requiere bastante tiempo para adaptarse a él.
Uno de los prejuicios más grandes que tengo, es por no tener obvio el comando “compilar”, eso es lo que opina un fanático de DEV C++ 4, donde en el centro de la barra de herramientas aparecen los tres botones: “Compilar”, “Correr”, o para ir de un solo al mandado, “Compilar y correr”.
Hasta hace unos días encontré el comando “Construir” (Build).
El otro detalle que me ha llevado hasta el borde de la desesperación, es el casi infinito mar de configuraciones, un cuadro de diálogo tras otro, y en cada cuadro , “ene” posibilidades... hablando concretamente, en las configuraciones para el comando “Run...”, olvidé ese paso, por eso, no importaba cuantas veces creara un nuevo proyecto, o incluso un nuevo espacio de trabajo, el dichoso IDE seguía buscando el método main de la primera cosa que hice con eclipse, de modo que nunca encontraba los nuevos archivos.
Ese es el tipo de cosas que deja la sensación de no saber si el de ‘la falla’ es el usuario o el que diseñó el programa. Por convención, suele ser el usuario, ¿verdad?.

Una vez superadas esas dificultades con el IDE, el proyecto se pone en marcha luego de un poco de observación de la gramática en la definición de micro-C.

Aquí muestro el código del lexer

class lexico extends Lexer;
options{ k=4; }

TOK_IF: "if";
TOK_ELSE: "else";
TOK_RETURN: "return";
TOK_WHILE: "while";
TOK_BREAK: "break";
TOK_CONTINUE: "continue";
TOK_TYPE_INT: "int";
TOK_TYPE_CHAR: "char" ;
TOK_VOID: "void";

ASSIGN:('=');

ADD_OP:('+''-');

MUL_OP:('*''/');

EQ_OP:("==""!=");

REL_OP:("<="">=");

REL_OP2:("<"">");

OPEN_PAR:('(');

CLOSE_PAR: (')');

OPEN_BRACE:('{');

CLOSE_BRACE: ('}');

COMMA: (',');

SEMICOLON: (';');

SUSPENSIVE: "...";

SPACE: (' ''\r''\n'){$setType(Token.SKIP); } ;

IDENTIFIER:
(LETTER)(LETTERDIGIT)*
;

INTEGER_CONSTANT:
(ZERO)(NONZERO)(DIGIT)*
;

protected ZERO:'0';
protected NONZERO:('1'..'9');
protected DIGIT:(ZERONONZERO);

protected LETTER:('a'..'z''A'..'Z''_') ;

CHAR_CONSTANT: ('\'')(LETTERDIGIT)('\''); //aun falta

STRING_CONSTANT: ('\"')()('\"'); //aun falta

protected COMMENT: "/*"()"*/";

Las definiciones de los operadores y palabras reservadas no dan mayor problema, solamente hay que fijarse de definirlas antes que los identificadores, para que el “no-determinismo” no sea una dificultad extra.

Los elementos más complejos han resultado ser la constante de caracter y la constate de cadena. En realidad, solamente se trata de analizar con calma elcaso en particular.

Continuamos con el Parser
El parser es sin duda la parte más emocionante d este proyecto, hasta ahora. Resulta sorprendente que la “Teoría de la computación” sirva para algo, (al cursar esa clase, esa es la interrogante más popular, pero la única que el maestro no contesta... ¿porqué nos hace eso? ).
Al definir la gramática del lenguaje a nivel de tokens, se logra ver con toda claridad la estructura del programa, y como es de esperar, hay que tener ciertas delicadezas con esa gramática.
El primer problema que se detecta al introducir una gramática y compilar el código de ANTLR para el parser es el de “Infinite recursion...”. La recursión izquierda, como la conocemos en español, es el primer detalle a tratar.

Eliminando recursión izquierda
A continuación muestro las transformaciones que realicé a algunas de las producciones de la gramática provista por el profesor:
( léase el signo ‘&’ como ‘lamda’)

translation_unit -> external_declaration translation_unit external_declaration
--------------------------------------------------------------------------------
translation_unit -> external_declaration translation_item
translation_item -> external_declaration translation_item &

parameter_def_list -> type identifier parameter_def_list "," type identifier;
-------------------------------------------------------------------------------
parameter_def_list -> type identifier parameter_item
parameter_item -> "," type identifier parameter_item &

declarations -> declarations declaration &
---------------------------------------------
declarations -> declarative
declarative -> declaration declarative &

parameter_decl_list -> parameter_decl_list "," parameter_decl_spec parameter_decl_spec
----------------------------------------------------------------------------------------
parameter_decl_list -> parameter_decl_spec parameter_declarative
parameter_declarative -> "," parameter_decl_spec parameter_declarative &

statement_list -> statement_list statement statement
------------------------------------------------------
statement_list -> statement statement_item
statement_item -> statement statement_item &

simple_expression -> simple_expression add_op term term
---------------------------------------------------------
simple_expression -> term simple_expression_
simple_expression_ -> add_op term simple_expression_ &

term -> term mul_op factor factor
-----------------------------------
term -> factor term_
term_ -> mul_op factor term_ &

expression_list -> expression_list "," expression expression
--------------------------------------------------------------
expression_list -> expression expression_list_
expression_list_ -> "," expression expression_list_ &

identifier_list -> identifier_list "," identifier identifier
---------------------------------------------------------------
identifier_list -> identifier identifier_list_
identifier_list_ -> "," identifier identifier_list_ &

Este procedimiento resulta relativamente sencillo, ya que la transformación implica solamente aplicar una fórmula de dos pasos.

Producciones no deterministas
Un segundo problema resulta el no-determinismo de algunas de las producciones, generalmente las de la forma A -> B BC. En algunos casos, no basta para ANTLR aplicar factorización izquierda, por ejemplo, si hacemos A -> BH, H -> C ‘lambda’, ANTLR reportará no-determinismo en la producción H.
Todavía no he encontrado la manera de solucionar este problema; mencionando que para estos casos estoy utilizando el operador ‘?’, que significa “cero o una vez”, es decir H -> C?.

A continuación muestro la gramática para el Parser, en formato de ANTLR, encontrará marcadas con un ‘!!’ al inicio d la línea, aquellas producciones en las cuales he encontrado el problema arriba descrito.

class parsico extends Parser;

startRule: translation_unit;

translation_unit : external_declaration translation_item;

translation_item : (external_declaration translation_item)?;

!!external_declaration : function_definition declaration;

function_definition : function_def_header function_body;

function_def_header : return_type IDENTIFIER (OPEN_PAR) parameters_def (CLOSE_PAR);

return_type : type (TOK_VOID);

parameters_def : parameter_def_list (TOK_VOID);

parameter_def_list : type IDENTIFIER parameter_item;

parameter_item : ((COMMA) type IDENTIFIER parameter_item)?;

function_body : (OPEN_BRACE) declarations statement_list (CLOSE_BRACE);

declarations : declarative;

declarative : (declaration declarative)?;

!!declaration : variable_declaration function_declaration;

variable_declaration : type identifier_list (SEMICOLON);

function_declaration : return_type IDENTIFIER (OPEN_PAR)

!!parameters_decl (CLOSE_PAR) (SEMICOLON);

parameters_decl : parameter_decl_list parameter_decl_list (COMMA) (SUSPENSIVE) (TOK_VOID);

parameter_decl_list : parameter_decl_spec parameter_declarative;

!!parameter_declarative : (COMMA parameter_decl_spec parameter_declarative)?;

parameter_decl_spec : type IDENTIFIER;

statement_list : statement statement_item;

statement_item : (statement statement_item)?;

!!statement : expression (SEMICOLON)
(TOK_RETURN) statement_
(TOK_WHILE) (OPEN_PAR) expression (CLOSE_PAR) statement
(TOK_IF) (OPEN_PAR) expression (CLOSE_PAR) statement //else_statement
(TOK_IF) (OPEN_PAR) expression (CLOSE_PAR) statement (TOK_ELSE) statement
(OPEN_BRACE) statement_list (CLOSE_BRACE)
// (TOK_RETURN) (SEMICOLON)
(TOK_BREAK) (SEMICOLON)
(TOK_CONTINUE) (SEMICOLON);

statement_: expression SEMICOLON SEMICOLON;

//else_statement : (TOK_ELSE statement)?;

expression : equality_expression ((ASSIGN) equality_expression)?;

equality_expression : relational_expression ((EQ_OP) relational_expression)?;

relational_expression : simple_expression ((REL_OP) simple_expression)?;

simple_expression : term simple_expression_;

simple_expression_ : ((ADD_OP) term simple_expression_)?;

term : factor term_;

term_ : (MUL_OP factor term_)?;

factor :
constant
(ADD_OP) factor
IDENTIFIER ((OPEN_PAR) factor_)?
(OPEN_PAR) expression (CLOSE_PAR);

factor_ : (CLOSE_PAR) expression_list (CLOSE_PAR);

constant : STRING_CONSTANT numeric_constant CHAR_CONSTANT;

numeric_constant : INTEGER_CONSTANT;

expression_list : expression expression_list_;

expression_list_ : ((COMMA) expression expression_list_)?;

identifier_list : IDENTIFIER identifier_list_;

identifier_list_ : ((COMMA) IDENTIFIER identifier_list_)?;

type : (TOK_TYPE_INT) (TOK_TYPE_CHAR);

La mente se consuela con un clásico “un poco más de análisis bastará para hallar la solución...”

Este es el contenido de uno de los archivos que he probado con el “compilador”:
int uno(int x, char c){
int y, z, w;
char r, c;
if(c == c){break;}
return x + 3;
}

A estas alturas del proyecto, me siento más realizado si el código generado “acepta” el input, que si le encuentra errores, porque mientras no corrija el no-determinismo de la gramática, no se logra reconocer código válido, como en:

if(c == c){break;}else{continue;}.

Este tipo de input no es aceptada aún por la gramática expuesta más arriba.

Ahora viene la etapa de reportar errores. Aquí es donde “la mula botó a Genaro”.

Un reconocedor de expresiones a la brava( continuacion )

2005-02-09T21:35:00.001-06:00

En la publicación anterior, olvidé comentar otros problemas que tuve con ese reconocedor.
La primera de ellas es que para respetar el orden estándar de operaciones, la cadena re recorre al revés, por ejemplo en 1 + 2 + 3, si se recorre al revés, el primer operador reconocido es el ‘+’ que se encuentra entre el ‘2’ y el ‘3’.
Esa fue la única solución que se me ocurrió para que esa operación quedase mas profunda en el árbol construido.
Otra observación ( si no han compilado el código) es que tuve que utilizar un treeview, así que necesitarán el código del .vbp para que VB sepa que tiene que incluir el OCX adecuado.
Aquí les va el texto. Igual que antes: Copy & Paste, salvar con editor de texto plano con CualquierNombre.vbp.
Al abrirlo, asegurarse que el archivo incluido es el que hayan salvado de la publicación anterior, y prueben a correrlo.
Lamento tener que poner el texto aquí en el blog, ya se que es mas difícil leerlo asi, pero estoy teniendo problemas de log in con la página web a la cual pude haber subido todo en un simple .zip. [ cookies rejected ]
------------- archivo: Proyecto.vbp ---------------------
Type=Exe
Form=Pharser01.frm
Reference=*\G{00020430-0000-0000-C000-000000000046}#2.0#0#..\..\..\WINDOWS\System32\stdole2.tlb#OLE Automation
Object={831FDD16-0C5C-11D2-A9FC-0000F8754DA1}#2.0#0; MSCOMCTL.OCX
IconForm="Pharser01"
Startup="Pharser01"
HelpFile=""
Command32=""
Name="Pharser"
HelpContextID="0"
CompatibleMode="0"
MajorVer=1
MinorVer=0
RevisionVer=0
AutoIncrementVer=0
ServerSupportFiles=0
VersionCompanyName="Familia Lara"
CompilationType=0
OptimizationType=0
FavorPentiumPro(tm)=0
CodeViewDebugInfo=0
NoAliasing=0
BoundsCheck=0
OverflowCheck=0
FlPointCheck=0
FDIVCheck=0
UnroundedFP=0
StartMode=0
Unattended=0
Retained=0
ThreadPerObject=0
MaxNumberOfThreads=1

[MS Transaction Server]
AutoRefresh=1
------------------------ fin de archivo --------------------

Un reconocedor de expresiones a la brava

2005-02-09T21:35:00.000-06:00

Uno de mis intereses desde que aprendi a programar ha sido el de generar gráficas de funciones matemáticas. Esa parte es sencilla, si la función a graficar se coloca en el Código fuente. Por supuesto, una mejor implementación permitirá al usuario introducir la ecuación que desee. La primera solución que se viene a la mente – si no se tiene conocimiento sobre compiladores - es crear una estructura fija, que el usuario pueda llenar, evitando al máximo la cantidad de errores de input. Esto limita la capacidad del programa, y requiere un cambio de la interfase se desea ampliar la funcionalidad del programa.
La mejor alternativa: que el usuario pueda introducir la expresión tal y como se escribe en notación matemática. Aquí es donde viene la parte interesante.
Como construir un reconocedor reexpresiones matemáticas sin conocimiento de herramientas para crear compiladores, y aún sin saber aplicar la teoría de autómatas?Aquí presento un primer intento. Un programa en Visual Basic.

La idea básica para reconocer era: Dado que la mayoría de las expresiones matemáticas son binarias, encontrar un operador, subdividir el input (cadena de entrada) en tres partes, izquierda, operador, derecha.
El operador se convierte en la raíz de un árbol, y se llama recursivamente este procedimiento para poblar los hijos de este arbol.
Las dificultades relativas a la precedencia se resolvieron haciendo un exceso d pasadas, ya que en una primera pasada se buscan los operadores con mayor precedencia, como la exponenciación, en una segunda los ‘por’ y ‘entre’, y en otra más, los operadores de suma y resta, y considerando la recursión, la cadena completa se recorre hasta tres veces por cada operador.
La precedencia con los paréntesis se resolvía “bloqueando” el encuentro de operadores si se estaba en un nivel de paréntesis distinto de cero, y enviando luego la cadena entre paréntesis (removiendo los mismos) al procedimiento antes descrito.
He aquí el código para examinarlo y si lo desea, compilarlo. Fue creado usando VB 6.0.
Por favor disculpar el “abuso” con el nombre, en ese entonces no sabía exactamente de que se trataba...
Instrucciones: Copy & Paste en cualquier editor de texto plano, salvar como Pharser01.frm, crear un nuevo proyecto de VB, e incluir este formulario en el.
“Hay que caerse antes de aprender a caminar”
---------------------- Archivo: pharser01.frm -------------------
VERSION 5.00
Object = "{831FDD16-0C5C-11D2-A9FC-0000F8754DA1}#2.0#0"; "MSCOMCTL.OCX"
Begin VB.Form Pharser01
BorderStyle = 1 'Fixed Single
Caption = "Pharser01"
ClientHeight = 7335
ClientLeft = 45
ClientTop = 435
ClientWidth = 10470
BeginProperty Font
Name = "MS Sans Serif"
Size = 12
Charset = 0
Weight = 700
Underline = 0 'False
Italic = 0 'False
Strikethrough = 0 'False
EndProperty
LinkTopic = "Form1"
MaxButton = 0 'False
MinButton = 0 'False
ScaleHeight = 7335
ScaleWidth = 10470
StartUpPosition = 3 'Windows Default
Begin VB.ListBox varList
Height = 5760
Left = 7560
Sorted = -1 'True
TabIndex = 6
Top = 840
Width = 2655
End
Begin VB.CommandButton btnSolve
Caption = "&Solve"
Height = 375
Left = 8880
TabIndex = 5
Top = 0
Width = 1335
End
Begin MSComctlLib.TreeView Tree
Height = 5895
Left = 0
TabIndex = 2
Top = 840
Width = 7530
_ExtentX = 13282
_ExtentY = 10398
_Version = 393217
HideSelection = 0 'False
Indentation = 706
LabelEdit = 1
LineStyle = 1
Style = 4
Appearance = 1
End
Begin VB.CommandButton btnProccess
Caption = "&Proccess"
Height = 375
Left = 7560
TabIndex = 1
Top = 0
Width = 1335
End
Begin VB.TextBox txtPharse
Height = 420
Left = 0
TabIndex = 0
Top = 0
Width = 7575
End
Begin VB.Label Label3
Caption = "Variables:"
Height = 255
Left = 7560
TabIndex = 7
Top = 600
Width = 2655
End
Begin VB.Label Label2
BorderStyle = 1 'Fixed Single
Height = 615
Left = 0
TabIndex = 4
Top = 6720
Width = 10455
End
Begin VB.Label Label1
Caption = "Arbol de expresión:"
Height = 255
Left = 0
TabIndex = 3
Top = 600
Width = 4095
End
End
Attribute VB_Name = "Pharser01"
Attribute VB_GlobalNameSpace = False
Attribute VB_Creatable = False
Attribute VB_PredeclaredId = True
Attribute VB_Exposed = False
Option Explicit
Private Function MenosUnario(Expre As String, i As Integer) As Boolean
If i = 1 Then MenosUnario = True: Exit Function
If esOper(Mid(Expre, i - 1, 1)) Then MenosUnario = True: Exit Function
'if i > 2 and esOper(Mid(Expre, i - 2, 2)) Then MenosUnario = True: Exit Function
End Function

Sub Arbol(Expre As String, Optional index As Integer)
If Expre = "" Then Exit Sub
Dim aux As Node
Dim i As Integer, par As Integer: par = 0
Dim ParMid As Boolean
'si la cadena empieza y termina en parentesis, y no hay parentesis intermedios
'removemos los extremos.
For i = 2 To Len(Expre) - 1
If Mid(Expre, i, 1) = "(" Or Mid(Expre, i, 1) = ")" Then ParMid = True: Exit For
Next
If Not ParMid Then
If Mid(Expre, 1, 1) = "(" And Mid(Expre, Len(Expre), 1) = ")" Then Expre = Mid(Expre, 2, Len(Expre) - 2)
End If
If Len(Expre) = 0 Then Exit Sub
'Operadores Logicos( &: AND, : OR, !:NOT, ?:XOR
For i = Len(Expre) To 1 Step -1
If Mid(Expre, i, 1) = "(" Then par = par + 1
If Mid(Expre, i, 1) = ")" Then par = par - 1
If par > 0 Then Label2.Caption = "error de parentesis: " & Expre: Exit Sub
If Mid(Expre, i, 1) = "&" And par = 0 Then
If index = 0 Then
Set aux = Tree.Nodes.Add(, , , "&")
Else
Set aux = Tree.Nodes.Add(index, tvwChild, , "&")
End If
Arbol Mid(Expre, 1, i - 1), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
Exit Sub
End If
If Mid(Expre, i, 1) = "" And par = 0 Then
If index = 0 Then
Set aux = Tree.Nodes.Add(, , , "")
Arbol Mid(Expre, 1, i - 1), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
Else
Set aux = Tree.Nodes.Add(index, tvwChild, , "")
Arbol Mid(Expre, 1, i - 1), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
End If
Exit Sub
End If
If Mid(Expre, i, 1) = "!" And par = 0 Then
If i = 1 Then
If index = 0 Then
Set aux = Tree.Nodes.Add(, , , "!")
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
Else
Set aux = Tree.Nodes.Add(index, tvwChild, , "!")
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
End If
Exit Sub
End If
End If
If Mid(Expre, i, 1) = "?" And par = 0 Then
If index = 0 Then
Set aux = Tree.Nodes.Add(, , , "?")
Arbol Mid(Expre, 1, i - 1), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
Else
Set aux = Tree.Nodes.Add(index, tvwChild, , "?")
Arbol Mid(Expre, 1, i - 1), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
End If
Exit Sub
End If
Next
'Signos de Comparacion
For i = Len(Expre) To 1 Step -1
If Mid(Expre, i, 1) = "(" Then par = par + 1
If Mid(Expre, i, 1) = ")" Then par = par - 1
If par > 0 Then Label2.Caption = "error de parentesis: " & Expre: Exit Sub
If i > 1 Then
If Mid(Expre, i - 1, 2) = ">=" And par = 0 Then
If index = 0 Then
Set aux = Tree.Nodes.Add(, , , ">=")
Else
Set aux = Tree.Nodes.Add(index, tvwChild, , ">=")
End If
Arbol Mid(Expre, 1, i - 2), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
Exit Sub
End If
If Mid(Expre, i - 1, 2) = "<=" And par = 0 Then
If index = 0 Then
Set aux = Tree.Nodes.Add(, , , "<=")
Else
Set aux = Tree.Nodes.Add(index, tvwChild, , "<=")
End If
Arbol Mid(Expre, 1, i - 2), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
Exit Sub
End If
End If
If Mid(Expre, i, 1) = "=" And par = 0 Then
If index = 0 Then
Set aux = Tree.Nodes.Add(, , , "=")
Else
Set aux = Tree.Nodes.Add(index, tvwChild, , "=")
End If
Arbol Mid(Expre, 1, i - 1), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
Exit Sub
End If
If Mid(Expre, i, 1) = ">" And par = 0 Then
If index = 0 Then
Set aux = Tree.Nodes.Add(, , , ">")
Else
Set aux = Tree.Nodes.Add(index, tvwChild, , ">")
End If
Arbol Mid(Expre, 1, i - 1), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
Exit Sub
End If
If Mid(Expre, i, 1) = "<" And par = 0 Then
If index = 0 Then
Set aux = Tree.Nodes.Add(, , , "<")
Else
Set aux = Tree.Nodes.Add(index, tvwChild, , "<")
End If
Arbol Mid(Expre, 1, i - 1), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
Exit Sub
End If

Next
'signos de suma ( +, -)
For i = Len(Expre) To 1 Step -1
If Mid(Expre, i, 1) = "(" Then par = par + 1
If Mid(Expre, i, 1) = ")" Then par = par - 1
If par > 0 Then Label2.Caption = "error de parentesis: " & Expre: Exit Sub
If Mid(Expre, i, 1) = "+" And par = 0 Then
If index = 0 Then
Set aux = Tree.Nodes.Add(, , , "+")
Else
Set aux = Tree.Nodes.Add(index, tvwChild, , "+")
End If
Arbol Mid(Expre, 1, i - 1), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
Exit Sub
End If
If Mid(Expre, i, 1) = "-" And par = 0 Then
If Not MenosUnario(Expre, i) Then
If index = 0 Then
Set aux = Tree.Nodes.Add(, , , "-")
Arbol Mid(Expre, 1, i - 1), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
Else
Set aux = Tree.Nodes.Add(index, tvwChild, , "-")
Arbol Mid(Expre, 1, i - 1), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
End If
Exit Sub
Else 'menos unario
If i = 1 Then
If index = 0 Then
Set aux = Tree.Nodes.Add(, , , "_")
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
Else
Set aux = Tree.Nodes.Add(index, tvwChild, , "_")
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
End If
Exit Sub
End If
End If
End If
Next
'Signos de multiplicacion ( /, *)
For i = Len(Expre) To 1 Step -1
If Mid(Expre, i, 1) = "(" Then par = par + 1
If Mid(Expre, i, 1) = ")" Then par = par - 1
If par > 0 Then Label2.Caption = "error de parentesis: " & Expre: Exit Sub
If Mid(Expre, i, 1) = "*" And par = 0 Then
If index = 0 Then
Set aux = Tree.Nodes.Add(, , , "*")
Else
Set aux = Tree.Nodes.Add(index, tvwChild, , "*")
End If
Arbol Mid(Expre, 1, i - 1), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
Exit Sub
End If
If Mid(Expre, i, 1) = "/" And par = 0 Then
If index = 0 Then
Set aux = Tree.Nodes.Add(, , , "/")
Else
Set aux = Tree.Nodes.Add(index, tvwChild, , "/")
End If
Arbol Mid(Expre, 1, i - 1), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
Exit Sub
End If
Next
'Signo de exponenciacion
For i = Len(Expre) To 1 Step -1
If Mid(Expre, i, 1) = "(" Then par = par + 1
If Mid(Expre, i, 1) = ")" Then par = par - 1
If par > 0 Then Label2.Caption = "error de parentesis: " & Expre: Exit Sub
If Mid(Expre, i, 1) = "^" And par = 0 Then
If index = 0 Then
Set aux = Tree.Nodes.Add(, , , "^")
Else
Set aux = Tree.Nodes.Add(index, tvwChild, , "^")
End If
Arbol Mid(Expre, 1, i - 1), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
Exit Sub
End If
Next
'si no habia signos en la cadena:
If index = 0 Then
Tree.Nodes.Add , , , Expre
Else
Tree.Nodes.Add index, tvwChild, , Expre
End If
End Sub
Sub Arbol2(Expre As String, Tree As TreeView, Optional index As Integer)
If Expre = "" Then Exit Sub
Dim aux As Node
Dim i As Integer, par As Integer: par = 0
Dim ParMid As Boolean
'si la cadena empieza y termina en parentesis, y no hay parentesis intermedios
'removemos los extremos.
For i = 2 To Len(Expre) - 1
If Mid(Expre, i, 1) = "(" Or Mid(Expre, i, 1) = ")" Then ParMid = True: Exit For
Next
If Not ParMid Then
If Mid(Expre, 1, 1) = "(" And Mid(Expre, Len(Expre), 1) = ")" Then Expre = Mid(Expre, 2, Len(Expre) - 2)
End If
If Len(Expre) = 0 Then Exit Sub
'Operadores Logicos( &: AND, : OR, !:NOT, ?:XOR
For i = Len(Expre) To 1 Step -1
If Mid(Expre, i, 1) = "(" Then par = par + 1
If Mid(Expre, i, 1) = ")" Then par = par - 1
If par > 0 Then Label2.Caption = "error de parentesis: " & Expre: Exit Sub
If Mid(Expre, i, 1) = "&" And par = 0 Then
If index = 0 Then
Set aux = Tree.Nodes.Add(, , , "&")
Else
Set aux = Tree.Nodes.Add(index, tvwChild, , "&")
End If
Arbol Mid(Expre, 1, i - 1), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
Exit Sub
End If
If Mid(Expre, i, 1) = "" And par = 0 Then
If index = 0 Then
Set aux = Tree.Nodes.Add(, , , "")
Arbol Mid(Expre, 1, i - 1), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
Else
Set aux = Tree.Nodes.Add(index, tvwChild, , "")
Arbol Mid(Expre, 1, i - 1), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
End If
Exit Sub
End If
If Mid(Expre, i, 1) = "!" And par = 0 Then
If i = 1 Then
If index = 0 Then
Set aux = Tree.Nodes.Add(, , , "!")
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
Else
Set aux = Tree.Nodes.Add(index, tvwChild, , "!")
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
End If
Exit Sub
End If
End If
If Mid(Expre, i, 1) = "?" And par = 0 Then
If index = 0 Then
Set aux = Tree.Nodes.Add(, , , "?")
Arbol Mid(Expre, 1, i - 1), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
Else
Set aux = Tree.Nodes.Add(index, tvwChild, , "?")
Arbol Mid(Expre, 1, i - 1), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
End If
Exit Sub
End If
Next
'Signos de Comparacion
For i = Len(Expre) To 1 Step -1
If Mid(Expre, i, 1) = "(" Then par = par + 1
If Mid(Expre, i, 1) = ")" Then par = par - 1
If par > 0 Then Label2.Caption = "error de parentesis: " & Expre: Exit Sub
If i > 1 Then
If Mid(Expre, i - 1, 2) = ">=" And par = 0 Then
If index = 0 Then
Set aux = Tree.Nodes.Add(, , , ">=")
Else
Set aux = Tree.Nodes.Add(index, tvwChild, , ">=")
End If
Arbol Mid(Expre, 1, i - 2), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
Exit Sub
End If
If Mid(Expre, i - 1, 2) = "<=" And par = 0 Then
If index = 0 Then
Set aux = Tree.Nodes.Add(, , , "<=")
Else
Set aux = Tree.Nodes.Add(index, tvwChild, , "<=")
End If
Arbol Mid(Expre, 1, i - 2), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
Exit Sub
End If
End If
If Mid(Expre, i, 1) = "=" And par = 0 Then
If index = 0 Then
Set aux = Tree.Nodes.Add(, , , "=")
Else
Set aux = Tree.Nodes.Add(index, tvwChild, , "=")
End If
Arbol Mid(Expre, 1, i - 1), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
Exit Sub
End If
If Mid(Expre, i, 1) = ">" And par = 0 Then
If index = 0 Then
Set aux = Tree.Nodes.Add(, , , ">")
Else
Set aux = Tree.Nodes.Add(index, tvwChild, , ">")
End If
Arbol Mid(Expre, 1, i - 1), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
Exit Sub
End If
If Mid(Expre, i, 1) = "<" And par = 0 Then
If index = 0 Then
Set aux = Tree.Nodes.Add(, , , "<")
Else
Set aux = Tree.Nodes.Add(index, tvwChild, , "<")
End If
Arbol Mid(Expre, 1, i - 1), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
Exit Sub
End If

Next
'signos de suma ( +, -)
For i = Len(Expre) To 1 Step -1
If Mid(Expre, i, 1) = "(" Then par = par + 1
If Mid(Expre, i, 1) = ")" Then par = par - 1
If par > 0 Then Label2.Caption = "error de parentesis: " & Expre: Exit Sub
If Mid(Expre, i, 1) = "+" And par = 0 Then
If index = 0 Then
Set aux = Tree.Nodes.Add(, , , "+")
Else
Set aux = Tree.Nodes.Add(index, tvwChild, , "+")
End If
Arbol Mid(Expre, 1, i - 1), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
Exit Sub
End If
If Mid(Expre, i, 1) = "-" And par = 0 Then
If Not MenosUnario(Expre, i) Then
If index = 0 Then
Set aux = Tree.Nodes.Add(, , , "-")
Arbol Mid(Expre, 1, i - 1), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
Else
Set aux = Tree.Nodes.Add(index, tvwChild, , "-")
Arbol Mid(Expre, 1, i - 1), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
End If
Exit Sub
Else 'menos unario
If i = 1 Then
If index = 0 Then
Set aux = Tree.Nodes.Add(, , , "_")
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
Else
Set aux = Tree.Nodes.Add(index, tvwChild, , "_")
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
End If
Exit Sub
End If
End If
End If
Next
'Signos de multiplicacion ( /, *)
For i = Len(Expre) To 1 Step -1
If Mid(Expre, i, 1) = "(" Then par = par + 1
If Mid(Expre, i, 1) = ")" Then par = par - 1
If par > 0 Then Label2.Caption = "error de parentesis: " & Expre: Exit Sub
If Mid(Expre, i, 1) = "*" And par = 0 Then
If index = 0 Then
Set aux = Tree.Nodes.Add(, , , "*")
Else
Set aux = Tree.Nodes.Add(index, tvwChild, , "*")
End If
Arbol Mid(Expre, 1, i - 1), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
Exit Sub
End If
If Mid(Expre, i, 1) = "/" And par = 0 Then
If index = 0 Then
Set aux = Tree.Nodes.Add(, , , "/")
Else
Set aux = Tree.Nodes.Add(index, tvwChild, , "/")
End If
Arbol Mid(Expre, 1, i - 1), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
Exit Sub
End If
Next
'Signo de exponenciacion
For i = Len(Expre) To 1 Step -1
If Mid(Expre, i, 1) = "(" Then par = par + 1
If Mid(Expre, i, 1) = ")" Then par = par - 1
If par > 0 Then Label2.Caption = "error de parentesis: " & Expre: Exit Sub
If Mid(Expre, i, 1) = "^" And par = 0 Then
If index = 0 Then
Set aux = Tree.Nodes.Add(, , , "^")
Else
Set aux = Tree.Nodes.Add(index, tvwChild, , "^")
End If
Arbol Mid(Expre, 1, i - 1), aux.index
Arbol Mid(Expre, i + 1, Len(Expre) - i), aux.index
Exit Sub
End If
Next
'si no habia signos en la cadena:
If index = 0 Then
Tree.Nodes.Add , , , Expre
Else
Tree.Nodes.Add index, tvwChild, , Expre
End If
End Sub

Private Function esOper(str As String) As Boolean
Select Case str
Case "+": esOper = True: Exit Function
Case "-": esOper = True: Exit Function
Case "_": esOper = True: Exit Function
Case "*": esOper = True: Exit Function
Case "/": esOper = True: Exit Function
Case "^": esOper = True: Exit Function

Case "=": esOper = True: Exit Function
Case ">": esOper = True: Exit Function
Case "<": esOper = True: Exit Function
Case ">=": esOper = True: Exit Function
Case "<=": esOper = True: Exit Function

Case "&": esOper = True: Exit Function
Case "": esOper = True: Exit Function
Case "!": esOper = True: Exit Function
Case "?": esOper = True: Exit Function
End Select
esOper = False
End Function

Function palabra(signo As String) As String
Select Case palabra
Case "+": signo = "MAS"
Case "-": signo = "MENOS"
Case "_": signo = "NEG"
Case "*": signo = "POR"
Case "/": signo = "ENTRE"
Case "^": signo = "ELEVADO A"
Case "=": signo = "IGUAL A"
Case ">": signo = "MAYOR QUE"
Case "<": signo = "MENOR QUE"
Case ">=": signo = "MAYOR O IGUAL QUE"
Case "<=": signo = "MENOR O IGUAL QUE"
Case "&": esOper = "AND"
Case "": esOper = "OR"
Case "!": esOper = "NOT"
Case "?": esOper = "XOR"
End Select
End Function

Private Function Simetrical(Tree As TreeView) As String
Dim temp As String
If Tree.Nodes.Count = 0 Then
Simetrical = "NULL"
Exit Function
Else
Simetrical = SimOrder(Tree.Nodes(1))
End If
End Function
Function SimOrder(NODO As Node) As String
If NODO.Children = 0 Then
SimOrder = " " & NODO.Text & " "
Else
If NODO.Children = 2 Then
SimOrder = "(" & SimOrder(NODO.Child) & NODO.Text & SimOrder(NODO.Child.Next) & ")"
Else
SimOrder = "(" & NODO.Text & SimOrder(NODO.Child) & ")"
End If
End If
End Function
Function Solve(NODO As Node) As Double
If NODO.Children = 0 Then
If IsNumeric(NODO.Text) Then
Solve = CDbl(NODO.Text)
Else
Solve = Variable(NODO.Text)
End If
Else
Select Case NODO.Text
Case "+": Solve = Solve(NODO.Child) + Solve(NODO.Child.Next)
Case "-": Solve = Solve(NODO.Child) - Solve(NODO.Child.Next)
Case "_": Solve = -Solve(NODO.Child)
Case "*": Solve = Solve(NODO.Child) * Solve(NODO.Child.Next)
Case "/": Solve = Solve(NODO.Child) / Solve(NODO.Child.Next)
Case "^": Solve = Solve(NODO.Child) ^ Solve(NODO.Child.Next)
Case "=":
If Solve(NODO.Child) = Solve(NODO.Child.Next) Then
Solve = 1
Else
Solve = 0
End If
Case ">":
If Solve(NODO.Child) > Solve(NODO.Child.Next) Then
Solve = 1
Else
Solve = 0
End If
Case "<":
If Solve(NODO.Child) < Solve(NODO.Child.Next) Then
Solve = 1
Else
Solve = 0
End If
Case ">=":
If Solve(NODO.Child) >= Solve(NODO.Child.Next) Then
Solve = 1
Else
Solve = 0
End If
Case "<=":
If Solve(NODO.Child) <= Solve(NODO.Child.Next) Then
Solve = 1
Else
Solve = 0
End If
Case "&":
If Solve(NODO.Child) And Solve(NODO.Child.Next) Then
Solve = 1
Else
Solve = 0
End If
Case "":
If Solve(NODO.Child) Or Solve(NODO.Child.Next) Then
Solve = 1
Else
Solve = 0
End If
Case "!":
If Solve(NODO.Child) = 0 Then
Solve = 1
Else
Solve = 0
End If
Case "?": 'XOR
If Solve(NODO.Child) Xor Solve(NODO.Child.Next) Then
Solve = 1
Else
Solve = 0
End If
End Select
End If
End Function

Private Function VarDefn(var As String) As Boolean
'Averigua si una cadena corresponde con una variable ya definida
Dim i As Integer
For i = 0 To varList.ListCount - 1
If InStr(1, varList.List(i), var) <> 0 Then VarDefn = True: Exit Function
Next
VarDefn = False
End Function

Private Function Variable(var As String) As Double
'Busca en la lista de variables la definición y devuelve el valor asociado
Dim i As Integer
For i = 0 To varList.ListCount - 1
If InStr(1, varList.List(i), var) <> 0 Then
Variable = CDbl(Right(varList.List(i), Len(varList.List(i)) - InStr(1, varList.List(i), "=", vbTextCompare)))
Exit Function
End If
Next
End Function

Private Sub btnProccess_Click()
'Preproceso de la expresión
'Construir el arbol de expresión
If txtPharse.Text <> "" Then Tree.Nodes.Clear: Arbol2 txtPharse.Text, Tree
'Revisa el arbol:
Dim i As Integer
For i = 1 To Tree.Nodes.Count
Tree.Nodes(i).Expanded = True 'Expande todos los nodos para hacerlos visibles
Tree.Nodes(i).Text = Trim(Tree.Nodes(i).Text) 'Elimina los espacios antes y despues de la cadena
'Si un nodo contiene texto no numérico, no es operador ni variable definida, entonces:
If Not IsNumeric(Tree.Nodes(i).Text) And Not esOper(Tree.Nodes(i).Text) And Not VarDefn(Tree.Nodes(i).Text) Then
'Define la variable con el valor por defecto 0.0
varList.AddItem Tree.Nodes(i).Text & " = 0.0"
End If
Next
End Sub

Private Sub btnSolve_Click()
'Muestra la expresión que fue reconocida y la solución de la misma
Label2.Caption = Simetrical(Tree) & " = " & CStr(Solve(Tree.Nodes(1)))
End Sub

Private Sub txtPharse_KeyDown(KeyCode As Integer, Shift As Integer)
'Reacciona a la tecla <>
If KeyCode = vbKeyReturn Then btnProccess_Click
End Sub

Private Sub varList_DblClick()
'Edicion de variable
Dim str As String, igual As Integer
str = varList.List(varList.ListIndex)
igual = InStr(1, str, "=", vbTextCompare)
str = Mid(str, 1, igual) & " " & InputBox("Definir variable" & vbNewLine & Mid(str, 1, igual), , Mid(str, igual + 1, Len(str) - igual))
If IsNumeric(Mid(str, igual + 1, Len(str) - igual)) Then varList.List(varList.ListIndex) = str
End Sub

---------------- fin de archivo ---------------------------

Instalacion de Eclipse y Plug-ins

2005-01-26T13:02:00.000-06:00

Respecto a la plataforma Eclipse, no puedo estar mas feliz, NO SE REQUIERE INSTALACION, solamente hay que colocar una copia de la carpeta en un lugar adecuado, y comenzar a trabajar.
En cuanto a los Plug Ins, el modo de agregarlos parece confusa al principio, y tambien, por hacer caso de una recomendacion de "instalar todo", la descarga de los mismos se demoro al rededor de cinco horas. Los plug-ins de ANTRL por el contrario son de dimensiones reducidas y se descargan en aproximados 2 minutos. Todo lo anterior, refiriendose al enlace que proporciona la Universidad en el area de cafereria.

Los experimentos iniciales han resultado exitosos, y los resultados han sido positivos. La mayor de las dificultades estiba en el hecho de tener que adaptarse a una nueva interfase, familiarizarse con los nuevos comandos, tarea que realmente resulta de poco esfuerzo.

En lo referente a JavaDoc, esto es lo que resulta mas confuso, por tratarse de comandos poco comunes, no les encuentro parecido con HTML , RTF u otros tipos de texto autoformateado, por lo que se me dificulta un poco mas la creacion de los comentarios.