ANALISIS LXICO

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










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 ID, a>
<TKN CORAPER, [>
<TKN ID, indice>
<TKN CORCIERRE, ]>
<TKN NUM, 2>
<TKN OPADD, +>
<TKN NUM, 4>
ESPECIFICACIN DE LOS COMPONENTES LXICOS:
EXPRESIONES REGULARES
Se especican haciendo uso de expresiones regulares con tres operaciones
bsicas:
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 Letter digit other Accepting
1 2 No
2 2 2 [3] No
3 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 C }
Patrn 2 { cdigo C }
Patrn 3 { cdigo C }

Patrn n { cdigo C }
%%
{ cdigo auxiliar }

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:
Smbolo Uso Ejemplo
[] Definir clase [a-z]
- Definir Rangos [a-z]
\ Carcter de Escape para representar simb. Especiales \t
^ Negacin [^xy]
Representar una cadena de caracteres while
* + ( ) | Operadores habituales para expresiones regulares [0-9]+
? Opcionalidad [0-9]+(.[0-9]+)?
{ } Expansin macro definida en seccin primera { digit }
Existen los siguientes nombres internos
char * yytext; Almacena el lexema reconocido
int yyleng; Longitud del lexema
int yylong; Longitud del lexema
int yylex; Llamada al analizador, devuelve el tipo de token (o si EOF)
FILE * yyin; Fichero de entrada, por defecto stdin
FILE * yyout; Fichero de salida, por defecto stdout
char input(); Devuelve el carcter actual en buffer
void output(c); Escribe un carcter en la salida
void unput(c); Escribe un carcter al buffer de entrada
yywrap(); Finalizar el procesamiento de entradas


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.