Informe Avance Proyecto # 1 (Parte 2)

Puntos alcanzados del proyecto:

• Verificación de comentarios tipo:”{ … }”

//-- Comentario Sin Abrir "}"
<YYINITIAL> {TK_COMENTARIOCERRADO_1}* {
ClsErrores Handler = new ClsErrores();
Handler.Error( 2, yyline, yychar );
}
//-- Comentario Sin Abrir "*)"
<YYINITIAL> {TK_COMENTARIOCERRADO_2}* {
ClsErrores Handler = new ClsErrores();
Handler.Error( 2, yyline, yychar );
}
//-- Verifica el tipo de comentario "{ ... }"
<YYINITIAL> {TK_COMENTARIOABIERTO_1} { yybegin(COMMENTS1); }
<COMMENTS1> [^({TK_COMENTARIOABIERTO_2TK_COMENTARIOCERRADO_2})] { /**/ }
<COMMENTS1> {TK_COMENTARIOCERRADO_1} { yybegin(YYINITIAL); }
//-- Si dentro de un comentario "{ ... }" se encuentra "(*" se toma como comentario anidado
<COMMENTS1> {TK_COMENTARIOABIERTO_2}* {
yybegin(YYINITIAL);
ClsErrores Handler = new ClsErrores();
Handler.Error( 1, yyline, yychar );
}
//-- Si dentro de un comentario "{ ... }" se encuentra "*)" se toma como comentario anidado
<COMMENTS1> {TK_COMENTARIOCERRADO_2}* {
yybegin(YYINITIAL);
ClsErrores Handler = new ClsErrores();
Handler.Error( 1, yyline, yychar );
}
//-- Si dentro de un comentario "{ ... }" se encuentra "{" se toma como comentario anidado
<COMMENTS1> {TK_COMENTARIOABIERTO_1}* {
yybegin(YYINITIAL);
ClsErrores Handler = new ClsErrores();
Handler.Error( 1, yyline, yychar );
}

• Verificación de comentarios tipo:”(* … *)”

//-- Verifica el tipo de comentario "(* ... *)"
<YYINITIAL> {TK_COMENTARIOABIERTO_2} { yybegin(COMMENTS2); }
<COMMENTS2> [^({}TK_COMENTARIOABIERTO_2TK_COMENTARIOCERRADO_2)] { /**/ }
<COMMENTS2> {TK_COMENTARIOCERRADO_2} { yybegin(YYINITIAL); }
//-- Si dentro de un comentario "(* ... *)" se encuentra "{" se toma como comentario anidado
<COMMENTS2> {TK_COMENTARIOABIERTO_1}* {
yybegin(YYINITIAL);
ClsErrores Handler = new ClsErrores();
Handler.Error( 1, yyline, yychar );
}

//-- Si dentro de un comentario "(* ... )*" se encuentra "}" se toma como comentario anidado
<COMMENTS2> {TK_COMENTARIOCERRADO_1}* {
yybegin(YYINITIAL);
ClsErrores Handler = new ClsErrores();
Handler.Error( 1, yyline, yychar );
}

//-- Si dentro de un comentario "(* ... )*" se encuentra ")*" se toma como comentario anidado
<COMMENTS2> {TK_COMENTARIOABIERTO_2}* {
yybegin(YYINITIAL);
ClsErrores Handler = new ClsErrores();
Handler.Error( 1, yyline, yychar );
}

Nota: en la verificación de comentarios no se ha definido cuando el comentario es abierto, pero no se ha cerrado, ¿Alguna sugerencia?

Informe Avance Proyeto #1 (Parte 1)

Puntos Alcanzados del proyecto:

• Validar el tamaño de declaración de un Identificador

<YYINITIAL> {IDENTIFICADOR} {
int Len = yytext().length();
if (Len>12) {
ClsErrores Handler = new ClsErrores();
Handler.Error( 10, yyline, yychar );
}
else {
return new Symbol( sym.IDENTIFICADOR, new TokenValue( yytext(), yyline, yychar ) );
}
}

• Validar Strings

//-- Definicion para identificar cadenas de String
<YYINITIAL> {TK_APOSTROFE} { yybegin(STRING); }
<STRING>[^(\n'{}TK_COMENTARIOABIERTO_2TK_COMNETARIOCERRADO_2TK_APOSTROFE_2)] { string.append( yytext() ); }
<STRING> {TK_APOSTROFE} {
yybegin(YYINITIAL);
int Len = string.length();
if (Len>255) {
ClsErrores Handler = new ClsErrores();
Handler.Error( 5, yyline, yychar );
}
else {
return new Symbol( sym.STRINGCONST, new TokenValue( string.toString(), yyline, yychar ) );
}
}
<STRING> {TK_APOSTROFE_2} { string.append( "\'" ); }
<STRING> [{] { string.append( "{" ); }
<STRING> [}] { string.append( "}" ); }
<STRING> {TK_COMENTARIOABIERTO_2} { string.append( "(*" ); }
<STRING> {TK_COMENTARIOCERRADO_2} { string.append( "*)" ); }
//-- Si encuentra un salto de linea se determina como cadena invalida
<STRING> [\n] {
yybegin(YYINITIAL);
ClsErrores Handler = new ClsErrores();
Handler.Error( 6, yyline, yychar );
}

• Validar Carácter

//-- Definicion para identificar caracter
<YYINITIAL> {TK_COMILLA} { yybegin(CARACTER); }
<CARACTER> [^(\n\")] { caracter.append( yytext() ); }
<CARACTER> {TK_COMILLA} {
yybegin(YYINITIAL);
int Len = caracter.length();
System.out.println(caracter.toString());
if (Len==0) {
ClsErrores Handler = new ClsErrores();
Handler.Error( 8, yyline, yychar );
}
else if (Len>1) {
ClsErrores Handler = new ClsErrores();
Handler.Error( 7, yyline, yychar );
}
else {
return new Symbol( sym.CHARCONST, new TokenValue( caracter.toString(), yyline, yychar ) );
}
}

• Validar Número

<YYINITIAL> {NUMERO} {
Integer Numero = new Integer( yytext() );
int Num = Numero.intValue();
if (Num<-65536 Num>65536){
ClsErrores Handler = new ClsErrores();
Handler.Error( 4, yyline, yychar );
}
else {
return new Symbol( sym.NUMERO, new TokenValue( yytext(), yyline, yychar ) );
}
}

• Validar Números que empiecen con 0 amenos que sea el valor cero.

//-- Validacion para el token Número (no debe comenzar con cero a menos que sea el valor cero)
<YYINITIAL> [0]+[0-9]* {
yybegin(YYINITIAL);
ClsErrores Handler = new ClsErrores();
Handler.Error( 9, yyline, yychar );
}

Interfaz gráfica & Lexer

El ambiente grafica consta de tres áreas:

1. Menú: esta formado por el menú “opciones” y “Ayuda”. El menú “Opciones” presenta las opciones de poder cargar un archivo ya sea un programa de pascal o un archivo de texto. Además, presenta la opción de poder compilar el archivo cargado (cada vez que se compile se guardara el archivo y se ejecutara el Lexer y el Parser) y por ultimo se cuenta con la opción de salir del programa. El menú “Ayuda” brinda información sobre el programa y sobre su desarrollador.
2. Editor de Texto: es en donde se podrá editar código pascal este presentara en el lado izquierdo presentara la línea de código, en la parte inferior derecha presentara la columna en donde se encuentra actualmente y en la parte superior del editor se muestra la dirección del programa actualmente editando.
3. Mensajes de Error: es la parte en donde se muestra la serie de problemas que se encontraron al momento de compilar el programa, aquí se muestra el tipo de error y la posición en donde se encuentra.
   
   Lexer: es la fase en donde se identifican si las palabras reservadas del lenguaje, identificadores, números, caracteres, Strings, comentarios cumplen con las reglas definidas por el programador. Para realizar el analizador léxico se esta utilizando el pluging “ANTLR” (me oriente a utilizar este pluging ya que lo encontré un poco mas sencillo de utilizar). Como primer paso fue crear un archivo en donde se encontrara la definición del Lexer, es aquí en donde se establecen los tokens para las palabras reservadas, operadores lógicos y otros signos que pertenecen al alfabeto del lenguaje de pascal como ser: ‘.’, ‘;’, ‘(‘, ‘)’, etc. Además, se aplicaron los métodos visto en clase para definir lo que son dígitos, letras y con estos poder definir lo que son números, identificadores.
   
   Problemas:
   1.) la restricción de que los números no pueden empezar con el digito cero a menos que este representado el valor cero, Mi definición para número es “NUMERO: ‘0’(‘1’..’9’)(DIGITO)*”, ahora cuando lo compilo y encuentra por ejemplo el numero 001 me retorna que no se encontró ningún error y entiendo por que se así, aquí va mi pregunta ¿El Lexer es el que detecta esta restricción o es el parser?
   
   2.) Otro problema que tengo es cuando aplico la definición para identificadores “ID:LETRA(LETRADIGITO)*” para palabras largas (“Ej: paleontologo”) no me las acepta, pero si captura palabras pequeñas y estas si son aceptadas.

Editor Grafico de Turbo Dragon

El editor de pascal cuenta con las opciones de poder cargar archivos de pascal (*.pas) y archivos de texto, además el editor muestra en la parte izquierda el número de línea de cada línea de código que este contenido en el archivo. Al momento de compilar el código se mostrara todos los errores generados en un área de texto no editable en la cual se mostrar información acerca del error y en que posición se encuentra.

Nota: Todas las palabras reservadas se mostraran en negrita, Ej.: “for i=1 to 10”

¿Porque micro-pascal?, lo habia definido así por las restricciones que se tiene, como ser que solo numeros enteros, limite de parametros de funciones, etc.

Laboratorio # 1

Al principio tuve problemas para configurar las opciones jflex.bat, ya que la ruta el path de java no estaba correcto, por lo cual estuve un buen rato tratando de corregirlo, además, no sabia que el comando rem significaba comentarios.

Al no tener correcto el path de java no podía compilar Cup, pero después de corrgir el path todo salio muy bien. Después de esto no tuve problemas la generar el archivo yyler.java.

Tuve problemas para poder compilar los archivos parser.java, sym.java y yylex.java, me genero varios errore, los cuales quise corregir pero no puede llegar a compilar el archivo yylex.java, ya que no estaban definidas en la clase sym, algunos términos como “TIMES, PLUS, etc”, por consiguiente no pude correr Example.parser ni tampoco realizar los cambios que requería el laboratorio # 1.
También tuve problemas para aplicar las opciones de jflex en eclipse, no entendí muy bien que es lo que debía realizar.

Para el inciso de que solo acepte número menores que 64, primero construi una expresión regular en donde solamente incluyo los digitos del 0 al 64, cuando ingreso el numero aplico la expresión y si ese número no se encuentra definido muestro un mensaje de error.

para cambiar que la operacion se ejecutara con el ENTER y no con el punto y como, en el estado inicial verifico cuando se encuentre con una nueva linea...si la encuentra entonces ejecuta la operación.

Para generar la documentación del programa en Netbeans 3.6 es en la opción de generar Javadoc, primero debemos seleccionar la ubicación en donde se encuentra el archivo ejecutable de javadoc, que generalmente es en donde instalamos -j2sdk1-

Otra forma de verificar que el numero ingresado sea menor que 64, es mediante la función Yytext() (devuelve un String), la cual mantiene la información que se ingreso, este valor lo convertimos en su valor entero mediante la clase Integer, y luego verificamos que este valor entero sea menor que 64.

Eclipse Vs. Netbeans

El primer compilador de Java que utilice fue Netbeans 3.6, es una herramienta muy completa, el cual ofrece un entorno muy fácil de utilizar, y al que me he acostumbrado a usar. Una de las desventaja de Netbeans 3.6 es el consumo de recursos y pensé, es Java! así deben ser los compiladores, Pero no! Después de haber instaldo Eclipse compare el consumo de recursos entre ambos, y resulto que Eclipse consume menos recursos que Netbeans 3.6. Empecé a navegar en el entorno de Eclipse, el cual tiene a primera vista un bonito entorno. Eclipse es muy parecido a netbeans 3.6, lo cual me parece muy perfecto ya que estoy acostumbrado a Netbeans 3.6 y mucho mejor no consume muchos recursos.Algo que no me gusta es que Eclipse no hace diferencia de los "main Class", sino que hay que estar asignando mediante "Run..."cual es el Main. En cambio en Netbeans 3.6 si hace la diferencia y uno solo ejecuta el main que desea correr sin tener antes que asignar cual en "Main Class"