21/12/2007

Compilador de Pascal
Analizador lxico
Grupo 2: Antonio De Miguel Vicenti Daniel Dionne Gonzlez Borja Gmez Gmez Miguel Martnez Segura Alberto Miln Gutirrez

Grupo 2

Compilador de Pascal
Analizador lxico

Contenido
Contenido ..........................................................................................................................1 Introduccin ..................................................................................................................... 2 JFlex ................................................................................................................................. 2
Estructura del archivo .flex ...................................................................................................................... 2 Expresiones regulares .............................................................................................................................. 3

Lxico................................................................................................................................ 3
Especificacin ........................................................................................................................................... 3 Tokens ........................................................................................................................................................ 5 Implementacin........................................................................................................................................ 5

Tabla de smbolos ............................................................................................................ 6 Gestor de errores .............................................................................................................. 8

Errores .......................................................................................................................................................8 El tipo TError ............................................................................................................................................8 El Gestor de errores ..................................................................................................................................8 Uso del Gestor de Errores ........................................................................................................................8

Casos de prueba ............................................................................................................... 9

Prueba1.pas ............................................................................................................................................... 9 Prueba2.pas............................................................................................................................................. 10 Prueba3.pas..............................................................................................................................................11 Prueba4.pas............................................................................................................................................. 14 Prueba5.pas ............................................................................................................................................. 16 Prueba de un archivo que no exista o que este corrupto ..................................................................... 19

Grupo 2

Introduccin
JFlex
Para el desarrollo de nuestro analizador lxico hemos utilizado la herramienta JFlex (http://jflex.de/). Ms abajo se especifica con ms detalle la implementacin con esta herramienta.

Lxico
La seccin lxico del proyecto especificar el diseo e implementacin de las estructuras y codificaciones de los que dispone el analizador para interpretar el cdigo. Es la parte del proyecto en la que aparece el scanner y los tokens elegidos. As mismo nos servir para explicar detenidamente las expresiones regulares deducidas de pascal y las acciones semnticas asociadas. Tabla de smbolos

Gestor de errores
Para la gestin de errores hemos optado por el uso de un ArrayList con objetos de tipo TError que guardan informacin de la fila y la columna donde se produjo el error.

JFlex
Para la generacin del autmata de estados del analizador lxico hemos utilizado JFlex (http://jflex.de/). Se trata de una potente herramienta, que dadas las expresiones regulares que reconocen los tokens del lenguaje y sus acciones asociadas, generan el autmata reconocedor de forma automtica. En el cdigo se incluyen, en el paquete Lexico, el archivo original (Lexico.flex) y el compilado por JFlex, Lexico.java.

Estructura del archivo .flex

Una cabecera con las inclusiones de cdigo ( imports) necesarias. Una serie de variables utilizadas por JFlex para insertar las declaraciones, y la definicin del Token devuelto en el final del fichero. Cdigo empotrado (que se copia ad hoc al .java) en donde se declara la tabla de smbolos y se define la funcin creaToken(). Lo que hace esta funcin es instanciar un Token con la informacin generada por el autmata: return new Token(type.ordinal(), yyline, yycolumn, atributos); El ordinal hace referencia al enumerado, que dice de qu tipo de Token se trata. yyline hace referencia a la lnea donde est ubicado el Token. yycolumn hace referencia a la columna donde est ubicado el Token. atributos es un Object que define los atributos del Token, generados en esta funcin a partir del tipo. Luego viene el conjunto de expresiones regulares, que sigue un esquema: nombre_expresin = expresin_regular Ms abajo se explica cmo se definen las expresiones regulares. Por ltimo, se definen las acciones asociadas a los patrones, que bien pueden estar definidos por expresiones regulares en el apartado anterior, o se pueden definir directamente. Aqu se o o o o 2

Grupo 2

utiliza la funcin creaToken mencionada antes. Si llega al final y no ha entrado en ninguna de las acciones, entonces se considera que el Token es errneo y se notifica al gestor de errores.

Expresiones regulares
Introducimos aqu un pequeo resumen de cmo se escriben algunas expresiones regulares que hemos usado de JFlex, como referencia para aqullos que no conozcan el lenguaje: Expresin [A-Z] [^c] {n_e1}|{n_e2} {nombre} (exp)? (exp)* (exp)+ \. \{ \ \ \n \r \t Descripcin Conjuntos de caracteres del intervalo Conjunto de caracteres que excluye el carcter c e1 OR e2 Referencia al nombre de una expresin definida La expresin exp una sola vez La expresin exp cero o ms veces La expresin exp una o ms veces \: carcter de escape, representa los caracteres que le siguen. Caracteres especiales: nueva lnea, retorno, tabulacin

Lxico
Como ya se mencion en la introduccin, en esta seccin de proyecto se observa cmo se comporta el analizador lxico para gestionar cada entrada del cdigo. Podemos distinguir dos partes, la especificacin y la implementacin. En la primera comentaremos cmo es la gramtica que reconoce el analizador, cmo se ha diseado la estructura interna de los tokens del lenguaje y su codificacin. En la segunda parte, veremos la forma en que hemos plasmado en JAVA toda esta informacin y la interfaz de acceso para el analizador sintctico.

Especificacin
Gramtica
Estudiando el lenguaje pascal, llegamos a ciertas reglas con las que hemos generado una serie de expresiones regulares para reconocer los tokens. A continuacin mostramos dichas expresiones y las acciones semnticas que hemos asociado a dichos patrones. Expresiones Regulares letra = [A-Za-z] digito = [0-9] alfanumerico = {letra}|{digito} caracter = \'([^'])?\' cadena = \'([^'])*\' identificador = {letra}({alfanumerico})* entero = {digito}+ numeroE = \E | \e real = {digito}+\.{digito}+({numeroE}{digito}+)? llaveIzq = \{ llaveDer = \} comentarioIni = \(\* comentarioFin = \*\) todoMenosLlave = [^}] todoMenosParen = [^)] cuerpoComentario1= {todoMenosLlave}* cuerpoComentario2= {todoMenosParen}*

Grupo 2

comentario = {llaveIzq}{cuerpoComentario1}{llaveDer} | {comentarioIni}{cuerpoComentario2}{comentarioFin} espacio = [ \n\t\r] Nota: Expresiones codificadas en sintaxis de JFlex El autmata que obtenemos por la gramtica, obtenido gracias a JFlex minimizado y sin fallos se adjunta a este documento debido a su enorme extensin. Acciones semnticas asociadas a los patrones "*" { return creaToken(TipoToken.OPER_ARIT, TipoOperadoresAritmeticos.POR); } "+" { return creaToken(TipoToken.OPER_ARIT, TipoOperadoresAritmeticos.MAS); } "-" { return creaToken(TipoToken.OPER_ARIT, TipoOperadoresAritmeticos.MENOS); } "/" { return creaToken(TipoToken.OPER_ARIT, TipoOperadoresAritmeticos.DIVIDE); } ";" { return creaToken(TipoToken.SEPARADOR, TipoSeparadores.PUNTOYCOMA); } "," { return creaToken(TipoToken.SEPARADOR, TipoSeparadores.COMA); } "(" { return creaToken(TipoToken.ABREPAREN, yytext()); } ")" { return creaToken(TipoToken.CIERRAPAREN, yytext()); } "[" { return creaToken(TipoToken.ABRECORCHETE, yytext()); } "]" { return creaToken(TipoToken.CIERRACORCHETE, yytext()); } "(." { return creaToken(TipoToken.ABRECORCHETE, yytext()); } ".)" { return creaToken(TipoToken.CIERRACORCHETE, yytext()); } "and" { return creaToken(TipoToken.OPER_LOGICO, TipoOperadoresLogicos.AND); } "or" { return creaToken(TipoToken.OPER_LOGICO, TipoOperadoresLogicos.OR); } "not" { return creaToken(TipoToken.OPER_LOGICO, TipoOperadoresLogicos.NOT); } "xor" { return creaToken(TipoToken.OPER_LOGICO, TipoOperadoresLogicos.XOR); } "shl" { return creaToken(TipoToken.OPER_LOGICO, TipoOperadoresLogicos.DESP_IZQ); } "shr" { return creaToken(TipoToken.OPER_LOGICO, TipoOperadoresLogicos.DESP_DER); } "=" { return creaToken(TipoToken.OPER_RELACIONAL, TipoOperadoresRelacionales.IGUAL); } "<" { return creaToken(TipoToken.OPER_RELACIONAL, TipoOperadoresRelacionales.MENOR); } ">" { return creaToken(TipoToken.OPER_RELACIONAL, TipoOperadoresRelacionales.MAYOR); } "<=" { return creaToken(TipoToken.OPER_RELACIONAL, TipoOperadoresRelacionales.MENOROIGUAL); } ">=" { return creaToken(TipoToken.OPER_RELACIONAL, TipoOperadoresRelacionales.MAYOROIGUAL); } "!=" { return creaToken(TipoToken.OPER_RELACIONAL, TipoOperadoresRelacionales.DISTINTO); } ":" { return creaToken(TipoToken.SEPARADOR, TipoSeparadores.DOSPUNTOS); } ":=" { return creaToken(TipoToken.OPER_ASIGNACION, yytext()); } "." { return creaToken(TipoToken.SEPARADOR, TipoSeparadores.PUNTO); } "^" { return creaToken(TipoToken.PUNTERO, yytext()); } "#" { return creaToken(TipoToken.ASCII, yytext()); } "$" { return creaToken(TipoToken.HEXADECIMAL, yytext()); } {identificador} { return creaToken(TipoToken.IDENTIFICADOR, yytext()); } {entero} { return creaToken(TipoToken.LITERAL_ENTERO, new Integer(yytext())); } {real} { return creaToken(TipoToken.LITERAL_REAL, new Double(yytext()));} {caracter} { return creaToken(TipoToken.LITERAL_CARACTER, new Character(yytext().charAt(1)));} {cadena} { return creaToken(TipoToken.LITERAL_CADENA, new String(yytext().substring(1,yytext().length()-1)));} {comentario} /*En la versin final ignorar comentarios */ System.out.println("Comentario reconocido: " + yytext()); }

Grupo 2

{espacio} .

{ /* Ignora espacios. */ } { System.out.println("Caracter ilegal, '" + yytext() + "' linea: " + yyline + ", columna: " + yychar); Nota: Expresiones codificadas en sintaxis de JFlex

Tokens
La materia de trabajo esencial para un analizador lxico son los tokens, que deben estar bien especificados y con una estructura clara. Cada token de nuestro analizador consta de un tipo y de los atributos asociados a dicho token. Adems incluye la lnea y la columna donde se encuentra situado en el cdigo. Los tipos de token que pueden darse, responden a una lista concreta que hemos diseado partiendo del lenguaje Pascal. El scanner se encarga de elegir cual ser el tipo de un token recibido. Las directrices proporcionadas a JFlex, condicionadas por la gramtica del diseo y sus acciones asociadas obligan a que se encuentre siempre un tipo. En caso de que el token no se asociase a ningn patrn establecido, sera un error lxico. A continuacin mostramos una tabla orientativa del diseo de los tokens. Tipo de token EOF, PAL_RES, IDENTIFICADOR, PUNTERO, LITERAL_ENTERO, LITERAL_REAL, LITERAL_CARACTER, LITERAL_CADENA, OPER_ARIT, SEPARADOR, ABREPAREN, CIERRAPAREN, ABRECORCHETE, CIERRACORCHETE, OPER_RELACIONAL, OPER_ASIGNACION, OPER_LOGICO, SIMBOLO, ASCII, HEXADECIMAL Codificacin elegida (PAL_RES, [Puntero a tabla]) (IDENTIFICADOR, [Puntero a tabla]) (LITERAL_ENTERO, [valor entero]) (LITERAL_REAL, [valor double]) (LITERAL_CARACTER, [carcter]) (LITERAL_CADENA, [string]) (OPER_ARIT, [tipo enumerado asociado]) (SEPARADOR, [tipo enumerado asociado]) (ABREPAREN, []) (CIERRAPAREN,[]) (ABRECORCHETE, []) (CIERRACORCHETE, []) (OPER_RELACIONAL,[ tipo enumerado asociado]) (OPER_ASIGNACION, [tipo enumerado asociado]) (OPER_ARIT, [tipo enumerado asociado]) (OPER_LOGICO, [tipo enumerado asociado]) (OPER_ARIT, [tipo enumerado asociado]) (ASCII , []) (OPER_ARIT, [tipo enumerado asociado])

Cabe destacar que cada token lleva adems el numero de fila y columna de su posicin en el cdigo La interfaz con el analizador sintctico, a nivel del analizador lxico, se basar nicamente en un mtodo de solicitud de un nuevo token.

Implementacin

Grupo 2

Se ha decidido implementar el analizador en el lenguaje JAVA. Hemos diseado una estructura que simplifica el control del cdigo, permitiendo as la actualizacin del analizador con nuevos tipos de token o atributos de estos. La clase token.java, gestiona el objeto Token. Proporcionndole los atributos de los que ya hemos hablado en la especificacin. La clase principal es lexico.java, donde se empotra el cdigo recibido de JFlex, generando el scanner. Aqu se decide que tipo de token se recibe, se monta en un objeto Token y se procesa. Adems contiene el mtodo nextToken() gracias al cual el analizador sintctico solicita los nuevos tokens del analizador lxico. Las clases TipoToken.java, TipoOperadoresAritmeticos.java, TipoSeparadores.java, TipoOperadoresRelacionales.java y TipoOperadoresLogicos.java son de tipo enumerado. En ellas se definen todos los tipos considerados por el analizador. TipoToken.java es la ms genrica y las dems profundizan en cada uno de los tipos. A continuacin mostramos los tipos de token implementados, dentro de cada enumerado. Para informacin ms detallada sobre la implementacin, recomendamos consultar el javadoc adjunto. TipoToken EOF, PAL_RES, IDENTIFICADOR, PUNTERO, LITERAL_ENTERO, LITERAL_REAL, LITERAL_CARACTER, LITERAL_CADENA, OPER_ARIT, SEPARADOR, ABREPAREN, CIERRAPAREN, ABRECORCHETE, CIERRACORCHETE, OPER_RELACIONAL, OPER_ASIGNACION, OPER_LOGICO, SIMBOLO, ASCII, HEXADECIMAL TipoOperadoresLogicos AND, OR, NOT, XOR, DESP_IZQ, DESP_DER TipoOperadoresRelacionales IGUAL, MENOR, MAYOR, MENOROIGUAL, MAYOROIGUAL, DISTINTO TipoOperadoresAritmeticos MAS, MENOS, POR, DIVIDE

TipoSeparadores COMA, PUNTOYCOMA, PUNTO, DOSPUNTOS

Tabla de smbolos
La tabla de smbolos es la entidad contenedora de informacin y datos del compilador. Para ello se requiere un acceso rpido y ptimo a los datos necesarios durante el proceso, y dada la optimalidad de

Grupo 2

los objetos predefinidos por Sun MicroSystems en su JDK 1.6 hemos decidido el uso de listas dinmicas y tablas hash ofrecidas por el mismo. El esquema que la tabla de smbolos posee es el ofrecido en clase en su tercera implementacin. La tabla, actualmente, maneja mbitos y posee opciones de editabilidad. NOTA: Cabe sealar que la gestin de palabras reservadas del lenguaje est monitorizada e implementada dentro de una tabla perteneciente al mdulo presentado. La tabla de smbolos podra resumirse, en esquema, de la siguiente forma: Tabla de palabras reservadas Clave-String Valor-Tipo de palabra reservada. Lista de tablas para cada mbito Para cada tabla se sigue el siguiente esquema: Clave-String Valor-Lista polimrfica de atributos. La clave ser, en cada caso, el lexema particular de cada identificador y contendr asociada la lista de todos sus atributos. Se ha elegido una lista polimrfica general ( Object) para generalizar en todo lo posible los contenidos de la misma y facilitar las posibles prximas ediciones. Tabla organizadora: Clave-Entero Valor-Entero. Esta tabla asociar cada mbito con su "padre" a nivel de anidamiento segn la organizacin del cdigo. Puntero a mbito actual: Entero. El puntero sealar al mbito en el cual se encuentre el anlisis del cdigo en el momento actual. Flag de inserciones toleradas: Booleano. Este flag permitir, segn su valor, insertar nuevas entradas en la tabla de smbolos. Su gestin, y edicin, ser supuestamente controlada por el Analizador Sintctico o Semntico, segn se decida implementar.

Los mtodos ofrecidos por la clase son los descritos en la documentacin Javadoc del proyecto. Como decisin de diseo hay que referir las siguientes cualidades: Palabras reservadas: Si se intenta insertar un identificador cuyo lexema coincide con una palabra reservada se retornar la referencia a la tabla de palabras reservadas en su entrada correspondiente. Palabras ya declaradas: Si se intenta insertar un identificador cuyo lexema ya ha sido declarado, ya sea en el mbito actual o en cualquier mbito de orden superior de anidamiento, se retornar la referencia a dicha entrada, en el mbito que corresponda. Palabra nueva, escritura inhabilitada: Si se intenta insertar un identificador cuyo lexema no coincide con ninguno insertado previamente pero no est habilitado el flag de tolerar insercin se retornar el valor null para que el analizador lxico gestione el error de manera particular. Palabra nueva, escritura habilitada: Si no se cumple ninguna de las anteriores opciones, se generar una nueva entrada en la tabla del mbito actual y se retornar la referencia a la misma.

La tabla de smbolos est orientada al uso mximo posible desde su inicio, as que puede darse la situacin de tener que especificarla ms detalladamente en alguna seccin para su correcta funcionalidad segn avance el uso y necesidad de la misma.

Grupo 2

Gestor de errores
El gestor de errores incluye tres clases distintas: Errores TError GestorErrores.

Errores
Hemos creado un tipo enumerado con los tipos bsicos de errores: LEXICO_ELEMENTO_YA_INSERTADO Cuando ya se ha aadido un elemento con ese identificador. LEXICO_CARACTER_NO_VALIDO El carcter no genera un token vlido. LEXICO_ERROR_DE_IO Se produce un error de Entrada/Salida.

El tipo TError
El tipo TError contiene, en primer lugar, un parmetro del tipo enumerado Errores. Adems, contiene dos variables de tipo integer que guardan informacin de la lnea y la columna en la que se ha registrado el error. De esta manera cada error podr tratarse como una entidad independiente, y podr almacenarse de manera sencilla. Adems de los setters y getters de la lnea, la columna y el tipo de error, la clase TError contiene un mtodo toString() (que hereda de Object) que devuelve un String con la informacin del error con un formato legible por el usuario. Ejemplo: llamando a este mtodo con un error de tipo CARACTER_NO_VALIDO en la lnea 5, columna 17, el String ser: Lnea: 5 Columna: 17. CARCTER NO VALIDO.

El Gestor de errores
El gestor de errores del analizador lxico est implementado usando una lista tipo ArrayList de elementos de TError (ArrayList<TError>). El gestor de errores se comunica por el resto de bloques por una sencilla interfaz. Los mtodos principales son: setErrores(ArrayList<TError> errores) Setter que introduce el ArrayList de errores que se le introduce como parmetro como lista de errores del programa. insertaError(TError error) Inserta un error, que se le pasa como parmetro, en la lista de errores. Este es el mtodo principal que el resto de mdulos usan para la tarea de la gestin de errores.

Uso del Gestor de Errores

El mtodo principal main utiliza el gestor de errores de las siguientes maneras: Lo crea al comienzo de la ejecucin. Llama al mtodo gestor.muestraListaErrores() al terminar el escner para mostrar por pantalla los errores registrados. Cuando gestiona una excepcin de Entrada/Salida aade un nuevo error al gestor de errores.

Grupo 2

La unidad Lexico.java, en la funcin next_token() llama tambin al gestor de errores cuando el autmata llega a un estado de error por carcter no valido: gestor.insertaError(new GestorDeErrores.TError(Errores.LEXICO_CARACTER_NO_VALIDO,yyline,yycolumn));

Casos de prueba
A continuacin pasamos a mostrar algunas de las diferentes pruebas que hemos realizado, incluyendo el programa de entrada con sintaxis Pascal, y su respectivas salidas de tokens generadas por el analizador lxico. En la presente documentacin detallaremos tan solo algunas pruebas de las que hemos realizado, siendo estas lo suficientemente representativas como para que el lector se haga una idea del resultado general de las pruebas. Tanto estas, como otras pruebas se pueden encontrar en el proyecto, empezando desde el archivo con formato pruebaX.pas, donde X ser un nmero entre 1 y 12. Para ejecutar una prueba, simplemente bastar con ejecutar el proyecto. Antes de comenzar, aparecer una caja de dialogo en la que se nos pedir que insertemos la ruta del archivo que queremos procesar. Por defecto los hemos introducido en la carpeta Pruebas, as que veremos que en la venta que aparece aparecer /pruebas. Si queremos ejecutar, por ejemplo, el archivo Prueba1.pascal, tan solo tendremos que aadir al texto ya escrito /prueba/ (que se refiere a la carpeta del proyecto en la que queremos buscar), el nombre del archivo. Al final tendramos que ves escrito en la caja de dialogo /prueba/Prueba1.pascal. Al darle a aceptar se ejecutar el analizador lxico para esta prueba. Hemos intentado abarcar todos los casos posibles de palabras reservadas, as como de errores lxicos. A continuacin pasamos a detallar diferentes entradas y salidas de pruebas, as como una breve descripcin del cometido de cada prueba:

Prueba1.pas
Se hacen diferentes usos de las cadenas y los caracteres.

Entrada
Program var caracter : char; var estrin : String; begin caracter := 'a'; estrin := 'aa'; [pipi] (.pipi.) END.

Salida
Comentario reconocido: (*Este es para probar las cadenas y los caracteres, y los punteros de regalo*)

Grupo 2

Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token

"program" -> PAL_RES [38] Linea: 1 Columna: 0 "type" -> PAL_RES [37] Linea: 2 Columna: 2 "puntero" -> IDENTIFICADOR [puntero] Linea: 2 Columna: 7 "=" -> OPER_RELACIONAL [IGUAL] Linea: 2 Columna: 15 "^" -> PUNTERO [^] Linea: 2 Columna: 17 "real" -> PAL_RES [1] Linea: 2 Columna: 18 ";" -> SEPARADOR [PUNTOYCOMA] Linea: 2 Columna: 22 "var" -> PAL_RES [20] Linea: 3 Columna: 2 "caracter" -> IDENTIFICADOR [caracter] Linea: 3 Columna: 6 ":" -> SEPARADOR [DOSPUNTOS] Linea: 3 Columna: 15 "char" -> PAL_RES [3] Linea: 3 Columna: 17 ";" -> SEPARADOR [PUNTOYCOMA] Linea: 3 Columna: 21 "var" -> PAL_RES [20] Linea: 4 Columna: 2 "estrin" -> IDENTIFICADOR [estrin] Linea: 4 Columna: 6 ":" -> SEPARADOR [DOSPUNTOS] Linea: 4 Columna: 13 "String" -> PAL_RES [4] Linea: 4 Columna: 15 ";" -> SEPARADOR [PUNTOYCOMA] Linea: 4 Columna: 21 "begin" -> PAL_RES [22] Linea: 5 Columna: 0 "caracter" -> IDENTIFICADOR [caracter] Linea: 6 Columna: 1 ":=" -> OPER_ASIGNACION [] Linea: 6 Columna: 10 "'a'" -> LITERAL_CARACTER [a] Linea: 6 Columna: 13 ";" -> SEPARADOR [PUNTOYCOMA] Linea: 6 Columna: 16 "estrin" -> IDENTIFICADOR [estrin] Linea: 7 Columna: 1 ":=" -> OPER_ASIGNACION [] Linea: 7 Columna: 8 "'aa'" -> LITERAL_CADENA [aa] Linea: 7 Columna: 11 ";" -> SEPARADOR [PUNTOYCOMA] Linea: 7 Columna: 15 "[" -> ABRECORCHETE [] Linea: 8 Columna: 1 "pipi" -> IDENTIFICADOR [pipi] Linea: 8 Columna: 2 "]" -> CIERRACORCHETE [] Linea: 8 Columna: 6 "(." -> ABRECORCHETE [] Linea: 9 Columna: 1 "pipi" -> IDENTIFICADOR [pipi] Linea: 9 Columna: 3 ".)" -> CIERRACORCHETE [] Linea: 9 Columna: 7 "END" -> PAL_RES [12] Linea: 10 Columna: 0 "." -> SEPARADOR [PUNTO] Linea: 10 Columna: 3

Prueba2.pas
Se utiliza un puntero, as como la creacin de tipos definidos por el usuario

Entrada
Type tDimension = 1..100; eMatriz(f,c: tDimension) = array [1..f,1..c] of real; tRango = record f,c: tDimension value 1; end; tpMatriz = ^eMatriz;

Salida
Token "type" -> PAL_RES [37] Linea: 0 Columna: 0 Token "tDimension" -> IDENTIFICADOR [tDimension] Linea: 1 Columna: 0 10

Grupo 2

Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token

"=" -> OPER_RELACIONAL [IGUAL] Linea: 1 Columna: 11 "1" -> LITERAL_ENTERO [1] Linea: 1 Columna: 13 "." -> SEPARADOR [PUNTO] Linea: 1 Columna: 14 "." -> SEPARADOR [PUNTO] Linea: 1 Columna: 15 "100" -> LITERAL_ENTERO [100] Linea: 1 Columna: 16 ";" -> SEPARADOR [PUNTOYCOMA] Linea: 1 Columna: 19 "eMatriz" -> IDENTIFICADOR [eMatriz] Linea: 2 Columna: 0 "(" -> ABREPAREN [] Linea: 2 Columna: 7 "f" -> IDENTIFICADOR [f] Linea: 2 Columna: 8 "," -> SEPARADOR [COMA] Linea: 2 Columna: 9 "c" -> IDENTIFICADOR [c] Linea: 2 Columna: 10 ":" -> SEPARADOR [DOSPUNTOS] Linea: 2 Columna: 11 "tDimension" -> IDENTIFICADOR [tDimension] Linea: 2 Columna: 13 ")" -> CIERRAPAREN [] Linea: 2 Columna: 23 "=" -> OPER_RELACIONAL [IGUAL] Linea: 2 Columna: 25 "array" -> PAL_RES [7] Linea: 2 Columna: 27 "[" -> ABRECORCHETE [] Linea: 2 Columna: 33 "1" -> LITERAL_ENTERO [1] Linea: 2 Columna: 34 "." -> SEPARADOR [PUNTO] Linea: 2 Columna: 35 "." -> SEPARADOR [PUNTO] Linea: 2 Columna: 36 "f" -> IDENTIFICADOR [f] Linea: 2 Columna: 37 "," -> SEPARADOR [COMA] Linea: 2 Columna: 38 "1" -> LITERAL_ENTERO [1] Linea: 2 Columna: 39 "." -> SEPARADOR [PUNTO] Linea: 2 Columna: 40 "." -> SEPARADOR [PUNTO] Linea: 2 Columna: 41 "c" -> IDENTIFICADOR [c] Linea: 2 Columna: 42 "]" -> CIERRACORCHETE [] Linea: 2 Columna: 43 "of" -> PAL_RES [8] Linea: 2 Columna: 45 "real" -> PAL_RES [1] Linea: 2 Columna: 48 ";" -> SEPARADOR [PUNTOYCOMA] Linea: 2 Columna: 52 "tRango" -> IDENTIFICADOR [tRango] Linea: 3 Columna: 0 "=" -> OPER_RELACIONAL [IGUAL] Linea: 3 Columna: 7 "record" -> PAL_RES [11] Linea: 3 Columna: 9 "f" -> IDENTIFICADOR [f] Linea: 4 Columna: 0 "," -> SEPARADOR [COMA] Linea: 4 Columna: 1 "c" -> IDENTIFICADOR [c] Linea: 4 Columna: 2 ":" -> SEPARADOR [DOSPUNTOS] Linea: 4 Columna: 3 "tDimension" -> IDENTIFICADOR [tDimension] Linea: 4 Columna: 5 "value" -> IDENTIFICADOR [value] Linea: 4 Columna: 16 "1" -> LITERAL_ENTERO [1] Linea: 4 Columna: 22 ";" -> SEPARADOR [PUNTOYCOMA] Linea: 4 Columna: 23 "end" -> PAL_RES [12] Linea: 5 Columna: 0 ";" -> SEPARADOR [PUNTOYCOMA] Linea: 5 Columna: 3 "tpMatriz" -> IDENTIFICADOR [tpMatriz] Linea: 6 Columna: 0 "=" -> OPER_RELACIONAL [IGUAL] Linea: 6 Columna: 9 "^" -> PUNTERO [^] Linea: 6 Columna: 11 "eMatriz" -> IDENTIFICADOR [eMatriz] Linea: 6 Columna: 12 ";" -> SEPARADOR [PUNTOYCOMA] Linea: 6 Columna: 19

Prueba3.pas
11

Grupo 2

Uso de las sentencias while, for e if. Uso de arrays. Error por identificador mal construido: Podemos ver como hemos intentado declarar el identificador 1cont, pero como empieza por un digito, el lxico no reconoce que pueda ser un identificador, por lo que separa en dos tokens. 1 literal entero y un identificador.

Entrada
program recorridos; var cont1,cont2: integer; vector= array [1..100] of real; encontrado: boolean; 1cont: integer (* ejemplo de error por identificador mal construido *) begin cont1 := 1; cont2 := 1; (*recorrido con while*) while ((cont1 <= 100) AND (encontrado = false)) do begin if (vector[cont1] == 1) encontrado = true; else cont1 = cont1+1; end; (*recorrido con for*) for cont2 := 1 to 100 do Begin if (vector[cont2] = 1) then encontrado = true end; END.

Salida
Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token "program" -> PAL_RES [38] Linea: 0 Columna: 0 "recorridos" -> IDENTIFICADOR [recorridos] Linea: 0 Columna: 8 ";" -> SEPARADOR [PUNTOYCOMA] Linea: 0 Columna: 18 "var" -> PAL_RES [20] Linea: 2 Columna: 2 "cont1" -> IDENTIFICADOR [cont1] Linea: 2 Columna: 6 "," -> SEPARADOR [COMA] Linea: 2 Columna: 11 "cont2" -> IDENTIFICADOR [cont2] Linea: 2 Columna: 12 ":" -> SEPARADOR [DOSPUNTOS] Linea: 2 Columna: 17 "integer" -> PAL_RES [0] Linea: 2 Columna: 19 ";" -> SEPARADOR [PUNTOYCOMA] Linea: 2 Columna: 26 "vector" -> IDENTIFICADOR [vector] Linea: 3 Columna: 2 "=" -> OPER_RELACIONAL [IGUAL] Linea: 3 Columna: 8 "array" -> PAL_RES [7] Linea: 3 Columna: 10 "[" -> ABRECORCHETE [] Linea: 3 Columna: 16 "1" -> LITERAL_ENTERO [1] Linea: 3 Columna: 17 "." -> SEPARADOR [PUNTO] Linea: 3 Columna: 18

12

Grupo 2

Token "." -> SEPARADOR [PUNTO] Linea: 3 Columna: 19 Token "100" -> LITERAL_ENTERO [100] Linea: 3 Columna: 20 Token "]" -> CIERRACORCHETE [] Linea: 3 Columna: 23 Token "of" -> PAL_RES [8] Linea: 3 Columna: 25 Token "real" -> PAL_RES [1] Linea: 3 Columna: 28 Token ";" -> SEPARADOR [PUNTOYCOMA] Linea: 3 Columna: 32 Token "encontrado" -> IDENTIFICADOR [encontrado] Linea: 4 Columna: 2 Token ":" -> SEPARADOR [DOSPUNTOS] Linea: 4 Columna: 12 Token "boolean" -> PAL_RES [2] Linea: 4 Columna: 14 Token ";" -> SEPARADOR [PUNTOYCOMA] Linea: 4 Columna: 21 Token "1" -> LITERAL_ENTERO [1] Linea: 5 Columna: 2 Token "cont" -> IDENTIFICADOR [cont] Linea: 5 Columna: 3 Token ":" -> SEPARADOR [DOSPUNTOS] Linea: 5 Columna: 7 Token "integer" -> PAL_RES [0] Linea: 5 Columna: 9 Comentario reconocido: (* ejemplo de error por identificador mal construido *) Token "begin" -> PAL_RES [22] Linea: 7 Columna: 0 Token "cont1" -> IDENTIFICADOR [cont1] Linea: 9 Columna: 0 Token ":=" -> OPER_ASIGNACION [] Linea: 9 Columna: 6 Token "1" -> LITERAL_ENTERO [1] Linea: 9 Columna: 9 Token ";" -> SEPARADOR [PUNTOYCOMA] Linea: 9 Columna: 10 Token "cont2" -> IDENTIFICADOR [cont2] Linea: 10 Columna: 0 Token ":=" -> OPER_ASIGNACION [] Linea: 10 Columna: 6 Token "1" -> LITERAL_ENTERO [1] Linea: 10 Columna: 9 Token ";" -> SEPARADOR [PUNTOYCOMA] Linea: 10 Columna: 10 Comentario reconocido: (*recorrido con while*) Token "while" -> PAL_RES [26] Linea: 13 Columna: 3 Token "(" -> ABREPAREN [] Linea: 13 Columna: 9 Token "(" -> ABREPAREN [] Linea: 13 Columna: 10 Token "cont1" -> IDENTIFICADOR [cont1] Linea: 13 Columna: 11 Token "<=" -> OPER_RELACIONAL [MENOROIGUAL] Linea: 13 Columna: 17 Token "100" -> LITERAL_ENTERO [100] Linea: 13 Columna: 20 Token ")" -> CIERRAPAREN [] Linea: 13 Columna: 23 Token "AND" -> PAL_RES [17] Linea: 13 Columna: 25 Token "(" -> ABREPAREN [] Linea: 13 Columna: 29 Token "encontrado" -> IDENTIFICADOR [encontrado] Linea: 13 Columna: 30 Token "=" -> OPER_RELACIONAL [IGUAL] Linea: 13 Columna: 41 Token "false" -> IDENTIFICADOR [false] Linea: 13 Columna: 43 Token ")" -> CIERRAPAREN [] Linea: 13 Columna: 48 Token ")" -> CIERRAPAREN [] Linea: 13 Columna: 49 Token "do" -> PAL_RES [27] Linea: 13 Columna: 51 Token "begin" -> PAL_RES [22] Linea: 14 Columna: 3 Token "if" -> PAL_RES [23] Linea: 15 Columna: 3 Token "(" -> ABREPAREN [] Linea: 15 Columna: 6 Token "vector" -> IDENTIFICADOR [vector] Linea: 15 Columna: 7 Token "[" -> ABRECORCHETE [] Linea: 15 Columna: 13 Token "cont1" -> IDENTIFICADOR [cont1] Linea: 15 Columna: 14 Token "]" -> CIERRACORCHETE [] Linea: 15 Columna: 19 Token "=" -> OPER_RELACIONAL [IGUAL] Linea: 15 Columna: 21

13

Grupo 2

Token "=" -> OPER_RELACIONAL [IGUAL] Linea: 15 Columna: 22 Token "1" -> LITERAL_ENTERO [1] Linea: 15 Columna: 24 Token ")" -> CIERRAPAREN [] Linea: 15 Columna: 25 Token "encontrado" -> IDENTIFICADOR [encontrado] Linea: 16 Columna: 5 Token "=" -> OPER_RELACIONAL [IGUAL] Linea: 16 Columna: 16 Token "true" -> IDENTIFICADOR [true] Linea: 16 Columna: 18 Token ";" -> SEPARADOR [PUNTOYCOMA] Linea: 16 Columna: 22 Token "else" -> PAL_RES [25] Linea: 17 Columna: 3 Token "cont1" -> IDENTIFICADOR [cont1] Linea: 18 Columna: 5 Token "=" -> OPER_RELACIONAL [IGUAL] Linea: 18 Columna: 11 Token "cont1" -> IDENTIFICADOR [cont1] Linea: 18 Columna: 13 Token "+" -> OPER_ARIT [MAS] Linea: 18 Columna: 18 Token "1" -> LITERAL_ENTERO [1] Linea: 18 Columna: 19 Token ";" -> SEPARADOR [PUNTOYCOMA] Linea: 18 Columna: 20 Token "end" -> PAL_RES [12] Linea: 19 Columna: 3 Token ";" -> SEPARADOR [PUNTOYCOMA] Linea: 19 Columna: 6 Comentario reconocido: (*recorrido con for*) Token "for" -> PAL_RES [30] Linea: 23 Columna: 4 Token "cont2" -> IDENTIFICADOR [cont2] Linea: 23 Columna: 8 Token ":=" -> OPER_ASIGNACION [] Linea: 23 Columna: 14 Token "1" -> LITERAL_ENTERO [1] Linea: 23 Columna: 17 Token "to" -> PAL_RES [31] Linea: 23 Columna: 19 Token "100" -> LITERAL_ENTERO [100] Linea: 23 Columna: 22 Token "do" -> PAL_RES [27] Linea: 23 Columna: 26 Token "Begin" -> PAL_RES [22] Linea: 24 Columna: 5 Token "if" -> PAL_RES [23] Linea: 25 Columna: 7 Token "(" -> ABREPAREN [] Linea: 25 Columna: 10 Token "vector" -> IDENTIFICADOR [vector] Linea: 25 Columna: 11 Token "[" -> ABRECORCHETE [] Linea: 25 Columna: 17 Token "cont2" -> IDENTIFICADOR [cont2] Linea: 25 Columna: 18 Token "]" -> CIERRACORCHETE [] Linea: 25 Columna: 23 Token "=" -> OPER_RELACIONAL [IGUAL] Linea: 25 Columna: 25 Token "1" -> LITERAL_ENTERO [1] Linea: 25 Columna: 27 Token ")" -> CIERRAPAREN [] Linea: 25 Columna: 28 Token "then" -> PAL_RES [24] Linea: 25 Columna: 30 Token "encontrado" -> IDENTIFICADOR [encontrado] Linea: 26 Columna: 8 Token "=" -> OPER_RELACIONAL [IGUAL] Linea: 26 Columna: 19 Token "true" -> IDENTIFICADOR [true] Linea: 26 Columna: 21 Token "end" -> PAL_RES [12] Linea: 27 Columna: 7 Token ";" -> SEPARADOR [PUNTOYCOMA] Linea: 27 Columna: 10 Token "END" -> PAL_RES [12] Linea: 29 Columna: 0 Token "." -> SEPARADOR [PUNTO] Linea: 29 Columna: 3

Prueba4.pas
Declaracin de todo tipo de variables, as como uso de los dos tipos de comentarios. Error de carcter no vlido (el guin bajo en la sentencia y:= _ba).

Entrada
{ Programa Ejemplo para Analisis Lxico. }

14

Grupo 2

(* Segundo formato de comentarios *) program var i,j,k: integer; var x,y: real; var letra : char; var cadena : String; begin if (i > 10) then x := i + j * k / y; else y := i + j * k / x; x := 5.2E10; y := _ba; END.

Salida
Comentario reconocido: { Programa Ejemplo para Analisis Lxico. } Comentario reconocido: (* Segundo formato de comentarios *) Token "program" -> PAL_RES [38] Linea: 2 Columna: 0 Token "var" -> PAL_RES [20] Linea: 3 Columna: 2 Token "i" -> IDENTIFICADOR [i] Linea: 3 Columna: 6 Token "," -> SEPARADOR [COMA] Linea: 3 Columna: 7 Token "j" -> IDENTIFICADOR [j] Linea: 3 Columna: 8 Token "," -> SEPARADOR [COMA] Linea: 3 Columna: 9 Token "k" -> IDENTIFICADOR [k] Linea: 3 Columna: 10 Token ":" -> SEPARADOR [DOSPUNTOS] Linea: 3 Columna: 11 Token "integer" -> PAL_RES [0] Linea: 3 Columna: 13 Token ";" -> SEPARADOR [PUNTOYCOMA] Linea: 3 Columna: 20 Token "var" -> PAL_RES [20] Linea: 4 Columna: 2 Token "x" -> IDENTIFICADOR [x] Linea: 4 Columna: 6 Token "," -> SEPARADOR [COMA] Linea: 4 Columna: 7 Token "y" -> IDENTIFICADOR [y] Linea: 4 Columna: 8 Token ":" -> SEPARADOR [DOSPUNTOS] Linea: 4 Columna: 9 Token "real" -> PAL_RES [1] Linea: 4 Columna: 11 Token ";" -> SEPARADOR [PUNTOYCOMA] Linea: 4 Columna: 15 Token "var" -> PAL_RES [20] Linea: 5 Columna: 2 Token "letra" -> IDENTIFICADOR [letra] Linea: 5 Columna: 6 Token ":" -> SEPARADOR [DOSPUNTOS] Linea: 5 Columna: 12 Token "char" -> PAL_RES [3] Linea: 5 Columna: 14 Token ";" -> SEPARADOR [PUNTOYCOMA] Linea: 5 Columna: 18 Token "var" -> PAL_RES [20] Linea: 6 Columna: 2 Token "cadena" -> IDENTIFICADOR [cadena] Linea: 6 Columna: 6 Token ":" -> SEPARADOR [DOSPUNTOS] Linea: 6 Columna: 13 Token "String" -> PAL_RES [4] Linea: 6 Columna: 15 Token ";" -> SEPARADOR [PUNTOYCOMA] Linea: 6 Columna: 21 Token "begin" -> PAL_RES [22] Linea: 7 Columna: 0 Token "if" -> PAL_RES [23] Linea: 8 Columna: 3 Token "(" -> ABREPAREN [] Linea: 8 Columna: 6

15

Grupo 2

Token "i" -> IDENTIFICADOR [i] Linea: 8 Columna: 7 Token ">" -> OPER_RELACIONAL [MAYOR] Linea: 8 Columna: 9 Token "10" -> LITERAL_ENTERO [10] Linea: 8 Columna: 11 Token ")" -> CIERRAPAREN [] Linea: 8 Columna: 13 Token "then" -> PAL_RES [24] Linea: 8 Columna: 15 Token "x" -> IDENTIFICADOR [x] Linea: 9 Columna: 6 Token ":=" -> OPER_ASIGNACION [] Linea: 9 Columna: 8 Token "i" -> IDENTIFICADOR [i] Linea: 9 Columna: 11 Token "+" -> OPER_ARIT [MAS] Linea: 9 Columna: 13 Token "j" -> IDENTIFICADOR [j] Linea: 9 Columna: 15 Token "*" -> OPER_ARIT [POR] Linea: 9 Columna: 17 Token "k" -> IDENTIFICADOR [k] Linea: 9 Columna: 19 Token "/" -> OPER_ARIT [DIVIDE] Linea: 9 Columna: 21 Token "y" -> IDENTIFICADOR [y] Linea: 9 Columna: 23 Token ";" -> SEPARADOR [PUNTOYCOMA] Linea: 9 Columna: 24 Token "else" -> PAL_RES [25] Linea: 10 Columna: 3 Token "y" -> IDENTIFICADOR [y] Linea: 11 Columna: 6 Token ":=" -> OPER_ASIGNACION [] Linea: 11 Columna: 8 Token "i" -> IDENTIFICADOR [i] Linea: 11 Columna: 11 Token "+" -> OPER_ARIT [MAS] Linea: 11 Columna: 13 Token "j" -> IDENTIFICADOR [j] Linea: 11 Columna: 15 Token "*" -> OPER_ARIT [POR] Linea: 11 Columna: 17 Token "k" -> IDENTIFICADOR [k] Linea: 11 Columna: 19 Token "/" -> OPER_ARIT [DIVIDE] Linea: 11 Columna: 21 Token "x" -> IDENTIFICADOR [x] Linea: 11 Columna: 23 Token ";" -> SEPARADOR [PUNTOYCOMA] Linea: 11 Columna: 24 Token "x" -> IDENTIFICADOR [x] Linea: 12 Columna: 3 Token ":=" -> OPER_ASIGNACION [] Linea: 12 Columna: 5 Token "5.2E10" -> LITERAL_REAL [5.2E10] Linea: 12 Columna: 8 Token ";" -> SEPARADOR [PUNTOYCOMA] Linea: 12 Columna: 14 Token "END" -> PAL_RES [12] Linea: 13 Columna: 0 Token "." -> SEPARADOR [PUNTO] Linea: 13 Columna: 3 Linea: 13 Columna: 7. LEXICO CARACTER NO VALIDO

Prueba5.pas
Uso de los operadores booleanos y los relacionales

Entrada
(*operadores relacionales*) program boolsYrelacionales; var verdadero: boolean; falso: boolean; y: integer; x: integer;

16

Grupo 2

Begin verdadero := verdadero OR falso; verdadero := verdadero AND verdadero; falso := falso AND verdadero; falso := verdadero AND NOT verdadero; if if if if if (x<y) then x:= y; (x<=y) then x:= y; (x>y) then x:= y; (x>=y) then x:= y; (x=y) then x:= y;

End.

Salida
Comentario reconocido: (*operadores relacionales*) Token "program" -> PAL_RES [38] Linea: 2 Columna: 0 Token "boolsYrelacionales" -> IDENTIFICADOR [boolsYrelacionales] Linea: 2 Columna: 8 Token ";" -> SEPARADOR [PUNTOYCOMA] Linea: 2 Columna: 26 Token "var" -> PAL_RES [20] Linea: 4 Columna: 0 Token "verdadero" -> IDENTIFICADOR [verdadero] Linea: 6 Columna: 0 Token ":" -> SEPARADOR [DOSPUNTOS] Linea: 6 Columna: 9 Token "boolean" -> PAL_RES [2] Linea: 6 Columna: 11 Token ";" -> SEPARADOR [PUNTOYCOMA] Linea: 6 Columna: 18 Token "falso" -> IDENTIFICADOR [falso] Linea: 7 Columna: 0 Token ":" -> SEPARADOR [DOSPUNTOS] Linea: 7 Columna: 5 Token "boolean" -> PAL_RES [2] Linea: 7 Columna: 7 Token ";" -> SEPARADOR [PUNTOYCOMA] Linea: 7 Columna: 14 Token "y" -> IDENTIFICADOR [y] Linea: 9 Columna: 0 Token ":" -> SEPARADOR [DOSPUNTOS] Linea: 9 Columna: 1 Token "integer" -> PAL_RES [0] Linea: 9 Columna: 3 Token ";" -> SEPARADOR [PUNTOYCOMA] Linea: 9 Columna: 10 Token "x" -> IDENTIFICADOR [x] Linea: 10 Columna: 0 Token ":" -> SEPARADOR [DOSPUNTOS] Linea: 10 Columna: 1 Token "integer" -> PAL_RES [0] Linea: 10 Columna: 3 Token ";" -> SEPARADOR [PUNTOYCOMA] Linea: 10 Columna: 10 Token "begin" -> PAL_RES [22] Linea: 16 Columna: 0 Token "verdadero" -> IDENTIFICADOR [verdadero] Linea: 18 Columna: 0 Token ":=" -> OPER_ASIGNACION [] Linea: 18 Columna: 10 Token "verdadero" -> IDENTIFICADOR [verdadero] Linea: 18 Columna: 13 Token "OR" -> PAL_RES [18] Linea: 18 Columna: 23 Token "falso" -> IDENTIFICADOR [falso] Linea: 18 Columna: 26 Token ";" -> SEPARADOR [PUNTOYCOMA] Linea: 18 Columna: 31 Token "verdadero" -> IDENTIFICADOR [verdadero] Linea: 19 Columna: 0 Token ":=" -> OPER_ASIGNACION [] Linea: 19 Columna: 10 Token "verdadero" -> IDENTIFICADOR [verdadero] Linea: 19 Columna: 13 Token "AND" -> PAL_RES [17] Linea: 19 Columna: 23 Token "verdadero" -> IDENTIFICADOR [verdadero] Linea: 19 Columna: 27

17

Grupo 2

Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token

";" -> SEPARADOR [PUNTOYCOMA] Linea: 19 Columna: 36 "falso" -> IDENTIFICADOR [falso] Linea: 20 Columna: 0 ":=" -> OPER_ASIGNACION [] Linea: 20 Columna: 6 "falso" -> IDENTIFICADOR [falso] Linea: 20 Columna: 9 "AND" -> PAL_RES [17] Linea: 20 Columna: 15 "verdadero" -> IDENTIFICADOR [verdadero] Linea: 20 Columna: 19 ";" -> SEPARADOR [PUNTOYCOMA] Linea: 20 Columna: 28 "falso" -> IDENTIFICADOR [falso] Linea: 21 Columna: 0 ":=" -> OPER_ASIGNACION [] Linea: 21 Columna: 6 "verdadero" -> IDENTIFICADOR [verdadero] Linea: 21 Columna: 9 "AND" -> PAL_RES [17] Linea: 21 Columna: 19 "NOT" -> PAL_RES [14] Linea: 21 Columna: 23 "verdadero" -> IDENTIFICADOR [verdadero] Linea: 21 Columna: 27 ";" -> SEPARADOR [PUNTOYCOMA] Linea: 21 Columna: 36 "if" -> PAL_RES [23] Linea: 24 Columna: 0 "(" -> ABREPAREN [] Linea: 24 Columna: 3 "x" -> IDENTIFICADOR [x] Linea: 24 Columna: 4 "<" -> OPER_RELACIONAL [MENOR] Linea: 24 Columna: 5 "y" -> IDENTIFICADOR [y] Linea: 24 Columna: 6 ")" -> CIERRAPAREN [] Linea: 24 Columna: 7 "then" -> PAL_RES [24] Linea: 24 Columna: 9 "x" -> IDENTIFICADOR [x] Linea: 24 Columna: 14 ":=" -> OPER_ASIGNACION [] Linea: 24 Columna: 15 "y" -> IDENTIFICADOR [y] Linea: 24 Columna: 18 ";" -> SEPARADOR [PUNTOYCOMA] Linea: 24 Columna: 19 "if" -> PAL_RES [23] Linea: 26 Columna: 0 "(" -> ABREPAREN [] Linea: 26 Columna: 3 "x" -> IDENTIFICADOR [x] Linea: 26 Columna: 4 "<=" -> OPER_RELACIONAL [MENOROIGUAL] Linea: 26 Columna: 5 "y" -> IDENTIFICADOR [y] Linea: 26 Columna: 7 ")" -> CIERRAPAREN [] Linea: 26 Columna: 8 "then" -> PAL_RES [24] Linea: 26 Columna: 10 "x" -> IDENTIFICADOR [x] Linea: 26 Columna: 15 ":=" -> OPER_ASIGNACION [] Linea: 26 Columna: 16 "y" -> IDENTIFICADOR [y] Linea: 26 Columna: 19 ";" -> SEPARADOR [PUNTOYCOMA] Linea: 26 Columna: 20 "if" -> PAL_RES [23] Linea: 28 Columna: 0 "(" -> ABREPAREN [] Linea: 28 Columna: 3 "x" -> IDENTIFICADOR [x] Linea: 28 Columna: 4 ">" -> OPER_RELACIONAL [MAYOR] Linea: 28 Columna: 5 "y" -> IDENTIFICADOR [y] Linea: 28 Columna: 6 ")" -> CIERRAPAREN [] Linea: 28 Columna: 7 "then" -> PAL_RES [24] Linea: 28 Columna: 9 "x" -> IDENTIFICADOR [x] Linea: 28 Columna: 14 ":=" -> OPER_ASIGNACION [] Linea: 28 Columna: 15 "y" -> IDENTIFICADOR [y] Linea: 28 Columna: 18 ";" -> SEPARADOR [PUNTOYCOMA] Linea: 28 Columna: 19 "if" -> PAL_RES [23] Linea: 30 Columna: 0 "(" -> ABREPAREN [] Linea: 30 Columna: 3 "x" -> IDENTIFICADOR [x] Linea: 30 Columna: 4

18

Grupo 2

Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token Token

">=" "y" ")" "then" "x" ":=" "y" ";" "if" "(" "x" "=" "y" ")" "then" "x" ":=" "y" ";" "if" "(" "x" "<" ">" "y" ")" "then" "x" ":=" "y" ";" "End" "."

-> OPER_RELACIONAL [MAYOROIGUAL] Linea: 30 Columna: 5 -> IDENTIFICADOR [y] Linea: 30 Columna: 7 -> CIERRAPAREN [] Linea: 30 Columna: 8 -> PAL_RES [24] Linea: 30 Columna: 10 -> IDENTIFICADOR [x] Linea: 30 Columna: 15 -> OPER_ASIGNACION [] Linea: 30 Columna: 16 -> IDENTIFICADOR [y] Linea: 30 Columna: 19 -> SEPARADOR [PUNTOYCOMA] Linea: 30 Columna: 20 -> PAL_RES [23] Linea: 32 Columna: 0 -> ABREPAREN [] Linea: 32 Columna: 3 -> IDENTIFICADOR [x] Linea: 32 Columna: 4 -> OPER_RELACIONAL [IGUAL] Linea: 32 Columna: 5 -> IDENTIFICADOR [y] Linea: 32 Columna: 6 -> CIERRAPAREN [] Linea: 32 Columna: 7 -> PAL_RES [24] Linea: 32 Columna: 9 -> IDENTIFICADOR [x] Linea: 32 Columna: 14 -> OPER_ASIGNACION [] Linea: 32 Columna: 15 -> IDENTIFICADOR [y] Linea: 32 Columna: 18 -> SEPARADOR [PUNTOYCOMA] Linea: 32 Columna: 19 -> PAL_RES [23] Linea: 34 Columna: 0 -> ABREPAREN [] Linea: 34 Columna: 3 -> IDENTIFICADOR [x] Linea: 34 Columna: 4 -> OPER_RELACIONAL [MENOR] Linea: 34 Columna: 5 -> OPER_RELACIONAL [MAYOR] Linea: 34 Columna: 6 -> IDENTIFICADOR [y] Linea: 34 Columna: 7 -> CIERRAPAREN [] Linea: 34 Columna: 8 -> PAL_RES [24] Linea: 34 Columna: 10 -> IDENTIFICADOR [x] Linea: 34 Columna: 15 -> OPER_ASIGNACION [] Linea: 34 Columna: 16 -> IDENTIFICADOR [y] Linea: 34 Columna: 19 -> SEPARADOR [PUNTOYCOMA] Linea: 34 Columna: 20 -> PAL_RES [12] Linea: 36 Columna: 0 -> SEPARADOR [PUNTO] Linea: 36 Columna: 3

Prueba de un archivo que no exista o que este corrupto

Si nos equivocamos de nombre de fichero, o intentamos introducir uno que no exista, se nos dar error de Entrada salida, y veremos esto en consola: Linea: -1 Columna: -1. LEXICO ERROR DE IO

19