UNIVERSIDAD NACIONAL DEL ALTIPLANO PUNO

FACULTAD DE INGENIERA MECNICA ELCTRICA ELECTRNICA Y SISTEMAS

ESCUELA PROFESIONAL DE INGENIERA DE SISTEMAS

ANLISIS LXICO

CURSO: Compiladores INGENIERO: Vladimir Crespo

INTEGRANTES DE GRUPO:
ACERO ZAPANA, Roy D. ESCALANTE APAZA, Mijail ANAHUA PEALOZA Alex W.

PUNO PER 2013

Contenido
FUNCIONES DEL ANALIZADOR LXICO .................................................................................. 3 VENTAJAS DE SEPARAR EL ANLISIS LXICO..................................................................... 4 COMPONENTES LXICOS, PATRONES, LEXEMAS .............................................................. 4 ESPECIFICACIN DE LOS COMPONENTES LXICOS: EXPRESIONES REGULARES 5 RECONOCIMIENTO DE LOS COMPONENTES LXICOS: AUTMATAS FINITOS.......... 6 Componente lxico: ..................................................................................................................... 6 Autmatas finitos determinsticos .............................................................................................. 6 IMPLEMENTACIN DE UN ANALIZADOR LXICO. ................................................................ 7 Mediante bucles anidados .......................................................................................................... 7 Mediante una tabla de transiciones ........................................................................................... 8 ASPECTOS PRCTICOS PARA LA IMPLEMENTACIN DE UN ANLISIS LXICO........ 9 Principio de Mxima longitud ...................................................................................................... 9 Palabras reservadas versus identificadores ............................................................................ 9 Gestin de buffer de Entrada.................................................................................................... 10 Aspectos a tener en cuenta de la implementacin ............................................................... 10 TRATAMIENTO DE ERRORES LXICOS ................................................................................ 11 GENERADORES AUTOMTICOS DE ANALIZADORES LXICOS .................................... 12

ANLISIS LXICO
Segn (Louden, 2004, pg. 31): La fase de rastreo, o anlisis lxico, de un compilador tiene la tarea de leer el programa fuente como un archivo de caracteres y dividirlo en tokens. Los tokens son como las palabras de un lenguaje natural: cada token es una secuencia de caracteres que representa una unidad de informacin en el programa fuente. En resumen el analizador lxico se encarga del reconocimiento de tokens que pasa al analizador sintctico adems se interrelacionan con una tabla de smbolos que el analizador lxico elabora al reconocer identificadores, palabras clave que ingresan a esta tabla para un reconocimiento lxico adecuado.

FUNCIONES DEL ANALIZADOR LXICO

La funcin esencial del analizador lxico es leer los caracteres del cdigo fuente y generar lexemas que a su vez generan tokens. Los tokens son enviados al analizador sintctico cuando este los requiere a travs del siguiente procedimiento. El analizador sintctico requiere que le enven un token, el analizador lxico revisa los caracteres del cdigo fuente, almacena algunos lexemas encontrados como identificadores en una tabla de smbolos donde en ocasiones los relaciona con un valor adicional para la identificacin del lexema en si, a su vez genera un token que es enviado al analizador sintctico. Estos componentes lxicos representan: Palabras reservadas: if, while, do, etc. Identicadores: asociados a variables, nombres de funciones, tipos denidos por el usuario, etiquetas,... Por ejemplo: posicin, velocidad, tiempo, etc. Operadores: = * + - / == > < & ! = , etc. Smbolos especiales: ; ( ) [ ] { },etc. Constantes numricas: literales que representan valores en- teros, en coma otante, etc, 982, 0xF678, -83.2E+2. Constantes de caracteres: literales que representan cadenas concretas de caracteres, hola mundo.

Dentro de otras funciones secundarias del analizador lxico se encuentran:: El manejo del fichero de entrada del programa fuente: abrirlo, leer sus caracteres, cerrarlo y gestionar posibles errores de lectura. Eliminar comentarios, espacios en blanco, tabuladores y saltos de lnea del cdigo fuente debido a que estos caracteres no son vlidos para la elaboracin de tokens. Inclusin de cheros: #include. La expansin de macros y funciones in-line: #dene. Contabilizar el nmero de lneas y columnas para emitir mensajes de error. Reconocimiento y ejecucin de las directivas de compilacin (por ejemplo, para depurar u optimizar el cdigo fuente).

VENTAJAS DE SEPARAR EL ANLISIS LXICO

Facilita transportabilidad del traductor (por ejemplo, si decidimos en un momento dado cambiar las palabras reservadas begin y end de inicio y n de bloque, por {y}, slo hay que cambiar este mdulo. Se simplica el diseo: el analizador es un objeto con el que se interacta mediante ciertos mtodos. Se localiza en un nico mdulo la lectura fsica de los caracteres, por lo que facilita tratamientos especializados de E/S.

COMPONENTES LXICOS, PATRONES, LEXEMAS

Patrn: es una regla que genera la secuencia de caracteres que puede representar a un determinado componente lxico. Lexema: cadena de caracteres que concuerda con un patrn que describe un componente lxico. Un componente lxico puede tener uno o innitos lexemas.

Los componentes lxicos se suelen denir como un tipo enumerado.

typedef enum{ TKN IF, TKN THEN, TKN NUM, TKN ID, TKN OPADD,...} TokenType;

Los componentes lxicos se representan mediante una estructura registro con tipo de token y lexema: typedef struct { TokenType token; char *lexema; //se reserva memoria dinmicamente } TokenRecord; TokenRecord getToken(void); a[indice]= 2 + 4

Cada componente lxico va acompaado de su lexema: <TKN <TKN <TKN <TKN <TKN <TKN <TKN ID, a> CORAPER, [> ID, indice> CORCIERRE, ]> NUM, 2> OPADD, +> NUM, 4>

ESPECIFICACIN DE LOS COMPONENTES LXICOS: EXPRESIONES REGULARES

Se especican haciendo uso de expresiones regulares con bsicas: tres operaciones

Concatenacin, repeticin (*) y alternativas (|) vamos a usar los siguientes metasmbolos: Una o ms repeticiones + r+ indica una o ms repeticiones de r (0|1)+ = (0|1)(0|1)*

Cualquier carcter. .*b.* indica cualquier cadena que contiene una letra b

Un rango de caracteres [ ] (clase) [a-z] indica cualquier carcter entre la a y z minsculas [a-z A-Z] indica cualquier letra del abecedario minscula o mayscula [0-9] indica cualquier dgito de 0 a 9 [abc] indica a|b|c. Cualquier carcter excepto un conjunto dado (a|b) indica cualquier carcter que no sea una a o b. Ejemplos:
nat = [0-9]+ signedNat = ( + | -)? nat number = signedNat(.nat)? (E signedNat)? Identicadores letter = [a-zA-Z] digit = [0-9] identifier = letter (letter | digit)* Palabras Reservadas tkn if = if tkn while = while tkn do = do

RECONOCIMIENTO DE LOS COMPONENTES LXICOS: AUTMATAS FINITOS

Componente lxico:
Es la secuencia lgica y coherente de caracteres relativo a una categora: identificador, palabra reservada, literales (cadena/numrica), operador o carcter de puntuacin, adems de que un componente lxico puede tener uno o varios lexemas.

Autmatas finitos determinsticos

Presentan las siguientes caractersticas: Tienen un solo camino de ejecucin para determinar la salida, es decir, de un estado no pueden salir varios caminos con igual componente lxico (Ver Figura 2). No pueden tener transiciones .

IMPLEMENTACIN DE UN ANALIZADOR LXICO.

Para este anlisis es importante tener en cuenta algunos conceptos como: Componentes lxicos o tokens, patrn o regla, lexema, cadena, lenguajes, alfabetos y un concepto muy importante que es el de expresiones regulares, a travs del cual se simplifica la especificacin de un lenguaje regular y sirve para especificar un patrn y por ltimo, los autmatas finitos, los cuales son grafos dirigidos que representan las acciones que tienen lugar al obtener el siguiente componente lxico, adems es la estructura que permite representar grficamente las expresiones regulares. Los conceptos anteriormente citados, como las expresiones regulares y autmatas finitos, son la parte fundamental para el reconocimiento de tokens o componentes lxicos. El proceso de reconocimiento desde el punto de vista terico requiere de conceptos muy abstractos que surgen de los lenguajes formales, sin embargo existen generadores como JavaCC y Jflap que facilitan ese reconocimiento o permiten identificar cadenas en una forma prctica sin necesidad de realizar un seguimiento analtico que implica mucho tiempo de anlisis y una excelente apropiacin del tema.

Un analizador lxico es responsable de: Manejo de apertura y cierre de archivo, lectura de caracteres y gestin de posibles errores de apertura. Eliminar comentarios, espacios en blanco, tabuladores y saltos de lnea. Inclusin de archivos y macros. Contabilizar nmero de lneas y columnas para emitir mensajes de error.

Mediante bucles anidados

Usamos una variable para almacenar el estado actual y una estructura tipo case doble anidada. El primer case comprueba el estado actual y el siguiente el carcter de entrada. Las transiciones se corresponden con asociar un nuevo estado a la variable y avanzar en la entrada.

ch=next input char; stete = 1; while (state == 1 o 2) do case state 1: case ch letter : avanzar en la entrada ; state=2; otro caso : state = error u otro fin_case; 2: case ch letter , digit : avanzar en la entrada; state =2 (no necesario); otro caso : state =3;

fin_case; fin_case; fin_while; if (state == 3) then aceptar else error;

El cdigo que se genera es largo y difcil de mantener en el caso de que introduzcan nuevos caracteres en el alfabeto de entrada o nuevos estados.

Mediante una tabla de transiciones

Input/state 1 2 3 Letter 2 2 digit 2 other [3] Accepting No No Yes

Se asume que los campos en blanco son errores. Los estados de aceptacin se marca con una columna adicional. Los corchetes representan que no se tiene que consumir un carcter en la entrada (no avanzar).;

state =1; ch = next_input_character; while (not accept [state]) and (not error(state)) do newstate = T[state,ch]; if advance[state,ch] then ch=next_input_char; state=newstate; end while; if accept[state] then accept; Advance y Accept son dos arrays booleanos indexados por el estado y por el carcter en la entrada. El primero indica si tenemos que avanzar en la entrada. El segundo si tenemos un estado de aceptacin Ventajas: el cdigo es reducido y fcil de mantener, sirve para cualquier analizador, las modificaciones se realizan solo en la tabla. Desventaja: tablas de gran tamao, se incrementa el espacio necesario (velocidad algo reducida respecto al mtodo anterior). Este mtodo es el que utiliza Flex (Linux) y Lex (Unix). Coste: O(|x|) , es independiente del tamao del autmata.

ASPECTOS PRCTICOS PARA LA IMPLEMENTACIN DE UN ANLISIS LXICO

Principio de Mxima longitud
Segn (Louden, 2004, pg. 46) cuando una cadena puede ser un token simple o una secuencia de varios tokens, por lo comn se prefiere la interpretacin del token simple. Esta preferencia se conoce a menudo como el principio de la sub-cadena ms larga; la cadena ms larga de caracteres que podran constituir un token simple en cualquier punto se supone que representa el siguiente token EL texto anterior se resume en cuestiones simple, de que el conjunto de caracteres ms largo se considera un componente lxico de mxima longitud, esto es debido a que para el anlisis lxico se trata de simplificar de una manera la interpretacin. Como por ejemplo: <> se interpreta cono el operador distinto de a pesar de que podra ser interpretado como dos identificadores menor que o mayor que pero para el analizador lxico sera un problema la identificacin de estos tokens por separado, de ah que se considera que la cadena de mxima longitud es considerada como un token nico.

Palabras reservadas versus identificadores

Segn (Aho, Lam, Sethi, & Ullman, 2008, pg. 132): El reconocimiento de las palabras reservadas y los identificadores presenta un problema. Por lo general, las palabras clave como if o then son reservadas, por lo que no son identificadores, aun cuando lo parecen Lo que trata de dar a entender en el texto anterior es que la identificacin de palabras reservadas y los identificadores generan problemas en determinados lexemas, dependiendo de como los identifiquen, por ejemplo si se aplica una expresin regular para la deteccin de identificadores, las palabras reservadas anteriores cumplen con la condicin por lo que genera un problema de considerarlo identificador o palabra clave. Posteriormente se muestra algunas formas de evitar dicho problema. Un lenguaje de programacin puede tener aproximadamente una cantidad de palabras reservadas. Para evitar que se genere un AFD demasiado grande las palabras reservadas se reconocen como identificadores y se comprueba antes de decir el tipo de token que es, si se trata de una palabra reservada o de un identificador consultando una tabla previamente inicializada con las palabras reservadas. Es recomendable generar dicha tabla cuando el nmero de palabras reservadas en muy grande. Dicho de otra forma, es necesario controlar estas palabras reservadas e insertar a la tabla de smbolos desde el inicio, debido a que van han ser identificados como tokens y nos indica que token representa.

Otra forma es la de crear diagramas de transicin de estados separados para cada palabra reservada, donde se va a identificar si la palabra reservada termina el recorrido y as considerarlo como token y no como un ID.

Gestin de buffer de Entrada

Segn (Aho, Lam, Sethi, & Ullman, 2008) define algunos problemas con la tarea de lectura del analizador lxico: vamos a examinar algunas formas en las que puede agilizarse la simple pero importante tarea de leer el programa fuente. Esta tarea se dificulta debido a que a menudo tenemos que buscar uno o ms caracteres ms all del siguiente lexema para poder estar seguros de que tenemos el lexema correcto. En resumen el proceso de lectura de los caracteres de la entrada y formar los componentes lxicos es lo ms costoso en tiempo en el proceso de traduccin debido a que debemos reconocer por lo menos un carcter ms adelante para verificar si se termin el lexema o no. Es importante implementarlo eficientemente. Por lo que existen mtodos y tcnicas para la lectura del cdigo fuente, por lo que se propone dos modelos, uno denominado pares de bferes y un modelo agregado con centinelas. Para el mtodo de pares de bferes utilizan dos bferes que se recargan alternamente y que son llenados a travs de una llamada de sistema por N caracteres, donde N es un bloque de disco ( es decir 4096 bytes)en cado de que para la llamada de sistema queden menos de n caracteres se agrega un carcter final de fin de archivo eof. Para la lectura se utilizan dos apuntadores, uno marca el inicio del lexema y el otro apuntador se mueve a travs de los caracteres hasta encontrar una sub-cadena que pertenezca a un patrn. Una vez reconocido un lexema ambos se colocan despus del lexema reconocido y el apuntador que lee los caracteres reconoce el siguiente lexema hasta que llega al fin del buffer o al fin de archivo, una vez llegado al fin del buffer se recarga el siguiente buffer donde se revisa a cada momento para verificar el fin de archivo o si se acab el buffer. El modelo de centinelas reduce un controla de mejor manera en la determinacin cuando se termina el buffer o el programa, mediante este mtodo al momento de recargar el buffer agrega un centinela para mejorar el reconocimiento de fin de archivo o del buffer, este centinela debe de ser una carcter que no afecte el reconocimiento de los dems por lo que usualmente es eof.

Aspectos a tener en cuenta de la implementacin

El anlisis lxico es una subrutina del anlisis sintctico que devuelve el tipo de componente lxico y el lexema cada vez que es llamado. Usar un tipo de enumerado para los tipos de componentes lxicos. Usar un tipo enumerado para los estados del analizador. En el analizador lxico debe haber una funcin de se encarga de gestionar el buffer de entrada. Se leer una lnea que se almacenara en un vector de caracteres. Cuando haya sido procesada se carga de nuevo.

Almacenara en variables el nmero de lnea y columna para emitir mensajes de error. Las palabras reservadas se reconocen como identificadores y antes de devolver un identificador se comprueba si es una palabra reservada o un identificador consultando en una tabla previamente inicializada con las palabras reservadas Hay casos en los que es necesario reinsertar un carcter en el buffer de entrada Adems de los componentes lxicos definidos por el lenguaje es conveniente aadir un par especiales para indicar el final de fichero y la deteccin de un error.

TRATAMIENTO DE ERRORES LXICOS

Los errores lxicos se detectan cuando el analizador lxico intenta reconocer componentes lxicos y la sub-cadena de caracteres de la entrada no encaja con ningn patrn. Son situaciones en las que se usa un carcter invalido (@, $,, , ), que no pertenece al vocabulario de lenguaje de programacin, al escribir mal un identificador, palabra reservada u operador. Los errores lxicos tpicos son: Nombres ilegales de identificadores: un nombre contiene caracteres invlidos. Nmeros incorrectos: un nmero contiene caracteres invlidos o no est formado correctamente, por ejemplo 3,14 en vez de 3.14 Errores de ortografa en palabras reservadas: caracteres omitidos, adicionales o cambiados de sitio, por ejemplo la palabra hwile en vez de while Fin de archivo: se detecta un fin de archivo a la mitad de un componente lxico.

Los errores lxicos se deben a descuidos del programador. En general, la recuperacin de errores lxicos es sencilla y siempre se traduce en la generacin de un error de sintaxis que ser detectado ms tarde por el analizador sintctico, cuando el analizador lxico devuelve un componente lrico que el analizador sintctico no espera en esa posicin. Los mtodos de recuperacin de errores lxicos se basan bien en saltarse caracteres en la entrada hasta que un patrn se ha podido reconocer; o bien usar otros mtodos mas sofisticados que incluyen la insercin borrado, sustitucin de un carcter en la entrada o intercambio de dos caracteres consecutivos. Una buena estrategia para la recuperacin de errores lxicos: Si en el momento de detectar el error ya hemos pasado por algn estado final ejecutamos la accin correspondiente al ltimo estado final visitado con el lexema formado hasta que salimos de l; el resto de caracteres ledos se devuelven al flujo de entrada y se devuelven al estado inicial; Si no hemos pasado ningn estado final, advertimos que el carcter encontrado no se esperaba, lo eliminamos y proseguimos con el anlisis.

Si se sabe que el siguiente componente lxico es una palabra reservada, es posible corregir la palabra mal escrita, por ejemplo si se ha escrito hwile en vez de while o fi en vez de if intercambiamos caracteres adyacentes.

GENERADORES AUTOMTICOS DE ANALIZADORES LXICOS

Todos los analizadores lxicos realizan la misma funcin (se implementan de igual forma) excepto en los tokens que reconocen las expresiones regulares que las definen. Resulta entonces natural y una forma de ahorrar esfuerzo, utilizar generadores automticos de analizadores lxicos. Esto generadores solo necesitan conocer la especificacin de tokens a reconocer. Las ltimas herramientas con las tcnicas de compresin de tablas ms eficientes son: FLEX (Fast Lexical Analyzer Generator) es un generador automtico de analizadores lxicos en lenguaje C. Es software de GNU. Entrada: un fichero de texto con la especificacin de los componentes lxicos, las expresiones regulares que los define. Salida: un programa en C que implementa dicho analizador, preparado para ser compilado y utilizado. Un fichero LEX consiste de tres partes: definiciones, reglas y rutinas auxiliares, separadas por %%. { definiciones } %% { reglas } %% Patrn 1 { cdigo Patrn 2 { cdigo Patrn 3 { cdigo Patrn n { cdigo %% { cdigo auxiliar

C } C } C } C } }

La seccin de definiciones incluye declaraciones de variables, constantes y definiciones regulares que pudieran ser utilizadas ms adelante. La seccin de reglas describe cada patrn y cada accionen un fragmento de cdigo que indica la accin que se debe realizar cuando se encuentra dicho patrn. La seccin de cdigo auxiliar contiene las funciones que pueden ser llamadas por las acciones de la seccin reglas. Algunas consideraciones: Cualquier cdigo C que se desea insertar va comprendido entre %{ y %}. FLEX hace correspondencia siempre con la cadena ms larga.

Si se verifican dos patrones, se elige la regla que aparece primero (colocar las palabras reservadas antes que los identificadores). Para definir las expresiones regulares se utiliza los smbolos:
Uso Definir clase Definir Rangos Carcter de Escape para representar simb. Especiales Negacin Representar una cadena de caracteres Operadores habituales para expresiones regulares Opcionalidad Expansin macro definida en seccin primera Ejemplo [a-z] [a-z] \t [^xy] while [0-9]+ [0-9]+(.[0-9]+)? { digit }

Smbolo [] \ ^ * + ( ) | ? { }

Existen los siguientes nombres internos

Almacena el lexema reconocido Longitud del lexema Longitud del lexema Llamada al analizador, devuelve el tipo de token (o si EOF) Fichero de entrada, por defecto stdin Fichero de salida, por defecto stdout Devuelve el carcter actual en buffer Escribe un carcter en la salida Escribe un carcter al buffer de entrada Finalizar el procesamiento de entradas

char * yytext; int yyleng; int yylong; int yylex; FILE * yyin; FILE * yyout; char input(); void output(c); void unput(c); yywrap();

Bibliografa
Aho, A. V., Lam, M. S., Sethi, R., & Ullman, J. D. (2008). Anlisis lxico. En A. V. Aho, M. S. Lam, R. Sethi, & J. D. Ullman, Compiladores, Principios, Tecnicas y Herramientas (pgs. 109-190). Mxico: Prentice Hall. Louden, K. C. (2004). Rastreo o anlisis lxico. En K. C. Louden, Contruccion de Compiladores (pgs. 31-94). Mxico: Ediciones Paraninfo, S.A.