2 Analisislexico

Leccin 2: Anlisis lxico
1) El papel de un analizador Aceptacin de un string por un

lxico (scanner) AF
2) Tokens, lexemas y patrones 5) Conversin de una expresin

lxicos regular en un AFN
3) Expresiones regulares 6) Transformacin de un AFN en
Su utilidad en compilacin
un AFD
Definicin 7) Minimizacin de un AFD
Ejemplos 8) Una introduccin breve a la
Notaciones implementacin de
analizadores lxicos
4) Autmatas finitos
Generalidades
Grafo de transiciones asociado
a un AF
Compiladores I. C.P.S. Universidad de Zaragoza -J.Ezpeleta- 1

El papel del analizador lxico
La funcin primordial es agrupar caracteres de la entrada en

tokens
Estos tokens son suministrados (bajo demanda) al analizador
sintctico
programa fuente
tabla de smbolos analizador lxico
(scanner)
tokens
analizador sintctico
(parser)
.....

prog: cabecera bloque .
El papel del analizador lxicocabecera: tkPROG tkID
cabecera: tkPROG tkID listaParsProg
listaParsProg: ( listaID )
listaID: listaID , ID
listaID: ID
....
program principal(input,output);
....
prog
yylex()
program
ProGRam cabecera bloque .
PRogram (tkPROG)
...
tkPROG tkID listaParsProg
yylex()
principal
pRinCipal (tkID,PRINCIPAL)
...

Pero, adems
procesar directivas al compilador
introducir informacin preliminar en la tabla de smbolos (se ver)
eliminar separadores innecesarios (cuando no lo ha hecho un
preprocesador)
sustituir macros
formatear y listar el fuente
A, veces cuando el lenguaje es sintcticamente complejo, dos
fases:
fase de examen
fase de anlisis (propiamente dicho)

Los tokens se pasan como valores simples

Algunos tokens requieren algo ms que su propia identificacin:
constantes: su valor
identificadores: el string
operadores relacionales: su identificacin
.....
Por lo tanto, el scanner debe realizar, a veces, una doble funcin:
identificar el token
evaluar el token

Esquema de procesamiento
especificacin
{v0,resultado,..}
{lexemas}
token
e.r. (ID,v0)
implementacin
letra(letra|digito)* AFN
AFD
AFD mnimo
Tokens, lexemas y patrones lxicos
Algunas definiciones:
token
nombre que se da a cada componente lxico
lexema
secuencia de caracteres de la entrada que
corresponden a un token
patrn
forma compacta de describir conjuntos de lexemas

*
Adems
un token se corresponde con un patrn
un token se puede corresponder con muchos lexemas
Ejemplo: Identificadores
token patrn
IDENTIFICADOR dgito
letra
lexemas letra
posicin _
v_0

Tokens ms habituales:
palabras reservadas
identificadores
operadores
constantes
smbolos de puntuacin: ; , . :
smbolos especiales: ()[]
Pero, a la vez que el propio token, el scanner puede (debe)
devolver ms informacin
si es un token CONSTANTE, su valor
si es un identificador, el string correspondiente
si es un smbolo de puntuacin, cul

Esta informacin, se devuelve mediante atributos

Pero an puede hacer algo ms:
puede detectar algunos (pocos) errores lxicos
no hay concordancia con ningn patrn
puede llevar a cabo algunas recuperaciones de errores
filtrado de caracters extraos
completar algn patrn
reemplazar algn carcter

Proceso de construccin (con ayuda de herramientas)

{e.r.+ acciones asociadas}
Generador de A.L.
(lex, flex, a mano,...)
c1...cn$ A.L. tktk-1...t1
ci:carcter
IkIk-1...I1 ti:token
Ii:informacin
asociada a ti

Qu pinta tiene un Pero puede ser complicado:

scanner? necesidad de recorrer varios
un conjunto de funciones caracteres antes de decidir el tipo de
token
una para cada smbolo a
reconocer pre-anlisis look-ahead
estas funciones son Ejemplo: reconocido < en C,
controladas/invocadas por puede corresponder a
una funcin que: MENOR <
selecciona, en funcin de MENOR_O_IGUAL <=
los caracteres de entrada,
SHIFT_LEFT <<
qu funcin invocar
IF vs. IFNI
Opcionalmente, tambin
mediante tablas

Expresiones regulares. Definiciones
alfabeto
conjunto finito de smbolos
ejemplo
{0,1}, letras y dgitos,.
cadena
secuencia finita de elementos del alfabeto
ejemplo
0010, estadoInicial, v_0,...

longitud de una cadena

nmero de elementos del alfabeto que la componen
ejemplos
|hola| = 4
|123456| = 6
= 0 (cadena vaca)
lenguaje
dado un alfabeto, cualquier conjunto de cadenas
formadas con dicho alfabeto
ejemplo
Siendo ={0,1} {0,01,011,0111,01111,...}

Operadores sobre lenguajes:

Sean L,M dos lenguajes
unin de lenguajes
L M = {c|c L c M}
concatenacin de lenguajes
L M = {st|s L y t M}
cerradura de Kleene cerradura positiva
L* =
i=0
Li L+ =
i=1
Li
CERO o MAS concatenaciones UNA o MAS concatenaciones

Para un token dado, los lexemas correspondientes los

expresaremos mediante expresiones regulares
Expresin regular: forma compacta para definir un lenguaje
regular
tambin llamado conjunto regular
lenguaje regular
El generado a partir de una expresin regular
Una expresin regular r:

ser definida a partir del lenguaje L(r) que genera
operadores sobre expresiones regulares mediante operadores sobre
lenguajes

Sea un alfabeto
expresin regular
1) es la expresin regular cuyo lenguaje es L()={}
2) Si a, a es la expresin regular cuyo lenguaje
es L(a)={a}
3)Sean r,s exp. reg. con lenguajes L(r) y L(s) a <> a
(r) es la exp. reg. cuyo lenguaje es L(r)

r|s es la exp. reg. cuyo lenguaje es L(r) L(s)
rs es la exp. reg. cuyo lenguaje es L(r)L(s)
r* es la exp. reg. cuyo lenguaje es (L(r))*

Importante:
3.4) da la posibilidad de uso de parntesis para establecer prioridades
Util, usar prioridades:
prioridad operador asociatividad
* izda.
concatenacin izda.
| izda.
expresiones regulares equivalentes

Generan el mismo lenguaje

Expresiones regulares. Ejemplos
Ejemplo 1: Sea ={a,b}

r L(r)
ab {ab}
a|b {a,b}
a* {,a,aa,aaa,aaaa,...}
ab* {a,ab,ab,abbb,...}
(ab|c)*d {d,abd,cd,abcd,ababcd,...}

Expresiones regulares. Ejemplos
Ejemplo 2: Sea ={0,1}

00 (00) el string 00
y todos los strings que empiezan con

(1|10)* 1 y no tienen dos 0 consecutivos,
(0|1)* todos los strings con 0 ms 1 0
y
(0|1)*00(0|1)* todos los strings con al menos 2 0

consecutivos
(0|)(1|10)*
todos los strings que no tengan dos 0
consecutivos
(0|1)*011 todos los strings que acaban en 011

Autmatas Finitos. Generalidades
Ya sabemos expresar los lexemas correspondientes a los tokens

Necesitamos implementar el analizador lxico
Esquema para su implementacin
Estamos aqu!
expresin
expresin A.L.
regular
regular
AFN AFD
AFD
AFN mnimo
mnimo
AFD
AFD

Autmatas Finitos. Generalidades
Los autmatas finitos pueden ser utilizados para reconocer los

lenguajes expresados mediante expresiones regulares
Un autmata finito (AF) es una mquina abstracta que reconoce
strings correspondientes a un conjunto regular
Tambin se denominan reconocedores
Misin de un AF:
reconocer si un string de entrada respeta las reglas determinadas por
una expresin regular
Ejemplo:
e.r.: (ab|c)*d
autmata?

Autmatas Finitos. Definiciones
Autmata Finito No Determinista
Un AFN es una 5-tupla (S,,,s0,F) donde:

1) S : conjunto de estados
2) : conjunto de smbolos de entrada
3) : funcin de transicin
: S x P(S)
4) s0 S : estado inicial
5) F S : conjunto de estados finales
(o de aceptacin)
: S x
Es posible que !!
P(S) !!
N.D.!

Autmatas Finitos. Grafo de transiciones
Notacin grfica:
s un estado
a transitar de s1 a s2
s1 s2
cuando se reconozca a
s0
s0 es el estado inicial
> s0
ff
f es un estado final
+ (de aceptacin)
f

Autmatas Finitos. Grafo de transiciones
AFN como grafo de transiciones

c 5 66
d
1 a d
33
b a c
inicio
2 4
1) S ={1,2,3,4,5,6}
2) ={a,b,c,d}
3) (1,c)={1} (1,d)={3} (1,a)={2,5} (2,b)={1}
(2,)={4} (4,c)={1} (5,b)={6}
4) s0 = 1
5) F = {3,6}
Autmatas Finitos. Aceptacin
Cmo funciona un AFN?

Dado un string, debe determinar si lo acepta o no
aceptacin de un string por un AFN
El string c1c2...cn es aceptado por un AFN

cuando existe, en el grafo de transiciones, un
camino
c1 c2 cn
s0 s1 s2 ... sm-1 sm
de manera que sm es un estado final (de

aceptacin)

Ejemplo:
Aceptara el autmata abcd? Y acd?
c
1 d
inicio
33
b a
2

Ejemplo:
Aceptara el autmata abcd?
El indeterminismo puede generar problemas de eficiencia (backtraking)
5 b
66
c a
inicio 1 d
33
b a
c
2
4

Autmatas Finitos Deterministas
Un Autmata Finito Determinista (AFD) es un caso particular de

AFN
Autmata Finito Determinista
Un AFD es un AFN tal que:

1) no etiqueta ningn arco
2) : S x S
Es decir:
toda transicin exige un smbolo distinto de
desde un estado, no hay dos arcos etiquetados con el mismo smbolo

Autmatas Finitos Deterministas
Simular un AFD
es muy sencillo Func simulaAFD(x,A) dev (acep:booleano)
y eficiente /* Pre: x es la cadena a aceptar
A=(S,,,s0,F) es el AFD
En lo que sigue: Post:acep = x es aceptado por A
dada una e.r., */
generar el AFN Variables sAct:estado {ERROR};i:entero
Convertir el Principio
AFN en un <i,sAct>:=<1,s0>
AFD y Mq sAct<>ERROR i<=length(x)
minimizarlo sAct:=mueve(A,sAct,x[i]) /*nico*/
Implementar el i:=i+1
AFD FMq Complejidad?
acep:=(sActF)
Fin

Conversin de una expresin regular a AFN
Objetivo: dada una expresin regular, generar un AFD que la

reconozca
Mtodo: construccin de Thompson (Bell Labs.)
AF para
S1
S2
inicio
AF para a
a
inicio S1 S2

AF para la expresin regular R1R2
R1 R2
inicio
AF para la expresin regular R1|R2

R1
inicio S1 S2
S2
R2
Ri AFN para Ri

Conversin de una e.r. en un AFN
AF para la expresin regular R*

R
inicio
S1 S2
S2
AF para un conjunto de ER
S1
R1
inicio
S2
R2
S
S3
R3

....

Ejemplo: proceso de construccin para

(ab|c)*d
(ab|c)* 1
d
22
inicio

d
inicio 3
ab|c 4 1 22


Conversin de una e. r. en un AFN
inicio
ab

3 5 8 4 1 d 22
6
c
7

9
a
10 11
b
12
inicio

3 5 8 4 1
d
22
6 c
7


Transformacin de un AFN en un AFD
Generar un AFN a partir de una e.r. es sencillo

Implementar un AFD es ms sencillo y eficiente que implementar
un AFN
Por lo tanto, es interesante saber generar, a partir de un AFN, un
AFD equivalente
El mtodo se basa en la idea de -clausura (ver [HoUl 79])

La idea bsica es que un estado del AFD agrupa un conjunto de

estados del AFN
Ejemplo:
1 2 a 55
inicio a a a b
AFN 3 b 4
a b
1,2 3,4,5
3,4,5 4,5
4,5
inicio a a
AFD b
55

Sea A=(S,,,s0,F)un AFN

-clausura de sS
Conjunto de estados de N alcanzables desde s
usando transiciones
-clausura de T S
clausura(s)
sT
mueve(T,c)
Conjunto de estados a los que se puede llegar

desde algn estado de de T mediante la
transicin c
Algoritmo Func simulaAFN(x,A) dev (acep:booleano)

para /* Pre: x es la cadena a aceptar
simular A=(S,,,s0,F) es el AFN
un AFN Post:acep = x es aceptado por A
*/
Variables T:conjunto(estados {ERROR})
i:entero
Principio
<i,T>:=<1,clausura({s0})>
Mq T<>{ERROR} i<=length(x)
T:=clausura(mueve(A,T,x[i]))
i:=i+1
FMq
acep:=(T F<>)
Fin
Ejercicio:
Escribir el algoritmo clausura
Func clausura(T,A) dev (c:conjEstados)

/* Pre: A es un AFN
T es un conjunto de nodos de A
Post:c= -clausura de T en A
*/

Minimizacin de AFD
Algunas cuestiones:
Como es lgico, cuantos ms estados tiene un AF, ms memoria es
necesaria
El nmero de estados del AFD se puede/debe minimizar (ver [HoUl 79])
inicialmente, dos estados:
uno con los de aceptacin
otro con los dems
sucesivas particiones de estados globales que no concuerdan con
algn sucesor para un smbolo de entrada
El AFD mnimo equivalente es nico

Minimizacin de AFD
Ejemplo:
b c
a 2 3 44
1
d 5 6 77
b c
1,2,3 c 4,7
4,7
5,6
1,2 b 3,6 c 4,7
5 4,7
a
1 2,5 b 3,6 c 4,7
4,7
d

Complejidad calculada:
espacio tiempo
AFN
AFN (|r|) (|r|x|x|)
AFD
AFD (2|r|) (|x|)
r: expresin regular
x: string a reconocer
A destacar:
AFN son mejores en espacio
tener en cuenta que en su AFD, cada estado del AFN se puede almacenar
varias veces
AFD son mejores en cuanto a velocidad de reconocimiento

Ejercicios 3 conv. curso 95/96
Ejercicio 1 (3 ptos.): Los identificadores para un determinado lenguaje de

programacin se definen de acuerdo con la siguiente descripcin:
Un identificador puede empezar con una letra o un "underscore" (carcter "_"), debe
estar seguido por 0 ms letras, dgitos o underscores, pero con las restricciones
siguientes:
1) No pueden aparecer dos underscores seguidos
2) Un identificador no puede terminar con un underscore.
Adems, no hay ninguna limitacin en cuanto a la longitud de los identificadores.
1.1) (1.5 ptos.) Dibujar el Autmata Finito Determinista que corresponde a los
identificadores descritos anteriormente.
Para etiquetar los arcos, en lugar de utilizar caracteres simples utilizar las siguientes
clases de caracteres:
letra [a-zA-Z] digito [0-9] und "_"
1.2) (1.5 ptos.) Dar una expresin regular correspondiente a los identificadores
descritos anteriormente

Ejercicios 2 conv. curso 96/97
Ejercicio 3 (0.75 ptos.): El libro "Pascal: User Manual and Report" de K.

Jensen y N. Wirth, que establece la especificacin ISO Pascal Standard,
define un comentario del lenguaje como (slo vamos a considerar
comentarios vlidos aqullos que empiezan por "(*" y terminan por "*)"):
"(*" seguido de cualquier secuencia de 0 ms caracteres que no contenga

"*)", y terminado por "*)
Escribir una expresin regular con sintaxis LEX para los comentarios Pascal
as definidos.
Ejercicio: Dar una expresin regular para los strings de Ada

Ejercicios
Ejercicio 3 (V2): El manual Pascal ISO 7185:1990, define un comentario

Pascal como sigue:
( "(* | { ) commentary ( *) | } )
where commentary is any sequence of characters and separations of lines

containing neither *) nor } and "(*, { do not occur inside commentary
Dar una expresin regular para esta versin de los comentarios

Ejercicios
Ejercicio 4: Considerar el siguiente Autmata Finito Determinista. Dar una

expresin regular que corresponda a dicho autmata.
1 0
0 1 2
1
1 0
0

Ejercicios
Ejercicio 5: Sea un alfabeto, y sea r una expresin regular sobre .

Vamos a denotar L(r) el lenguaje generado por la expresin r. Por otro
lado, siendo r y s dos expresiones regulares,
* rs representa el lenguaje L(rs)={ vw | v L(r) y w L(s)},
formado por las concatenaciones de una cadena de r y una de s
* r+s representa el lenguaje formado las cadenas de L(r) L(s)
* siendo n un nmero natural, rn representa el lenguaje generado la
concatenacin de n cadenas del lenguaje generado por r
* siendo n un nmero natural, nr representa el lenguaje generado la
(r+r+...n veces...+r)
El ejercicio pide razonar sobre la correccin o incorreccin de las

siguientes afirmaciones, donde r, s, t son expresiones regulares:
* r(s+t) = rs+rt
* rs si, y slo si, r+s
* (r+s)2 = r2 + s2 + 2rs
Sobre implementacin de AL
Un AFN se suele implementar:

mediante una
tabla
tabla de
de transiciones
transiciones
El grafo aparece explcitamente

Entrada: (estado, smbolo)
Salida: nuevo estado
a pelo
el grafo de transiciones no est explcitamente implementado

Sobre implementacin de AL
Ejemplo: (ab|c)*d
c
1
d
33
b a
inicio
2
smbolo entrada
e
s a b c d
t 1 2 ERR 1 3
a 2 ERR 1 ERR ERR
d
o 3 acep acep acep acep

Un analizador lxico muy simple
Propuesta:
Un analizador lxico menor <
para un evaluador de mayor >
expresiones menorIgual <=
mayorIgual >=
Involucra: igual =
constantes enteras sin distinto <>
signo letra a|b|...|z|A|B|....|Z
operadores relacionales digito 0|1|...|9
<,<=,>,>=,<>,= identificador
identificadores de letra (letra |digito)*
variables constEntera
digito digito*
Componentes lxicos:

Ejemplo de uso:
v0<>27 segundos= 1000
analizador
analizador
lxico
lxico
(IDENTIFICADOR,v0)
(DISTINTO,)
(CONSTENTERA,27)
(IDENTIFICADOR,segundos)
(IGUAL,)
(CONSTENTERA ,1000)

/*----------------------------------------------
Implementacin
PRE: con TTen stdin corresponde al
el primer carcter
primer carcter del siguiente lexema.
Cualquier valor para 'yylval', 'yytext',
'yyleng'
POST: se ha procesado un lexema. El siguiente
carcter en stdin corresponde al primer
carcter de un nuevo lexema.
* Devuelve el token correspondiente al
lexema tratado
* asignado a la variable global 'yylval'
el valor adecuado (si necesario)
* la var. global 'yytext' contiene el
lexema tratado
* la var. global 'yyleng' contiene la
long. del lexema
----------------------------------------------*/
token yylex() void main()
{ ........ } { token elToken;
void reconocido(token elToken)
{ ........ } do{
elToken=yylex();
reconocido(elToken);
}while(elToken!=FIN);
}
Un analizador lxico muy simple accin de
aceptacin
Grafo de estados: > 22 return(DISTINTO,)

1 = 33 return(MENORIGUAL,)
44 return(MENOR,)
<
separador
= 66 return(MAYORIGUAL,)
> 5
=
77 return(MAYOR,)
0 88 dev(IGUAL,)
letra digito
9 10 return(IDENTIFICADOR,
10
digito letra nombre)
11 12
separador representa 12 return(CONSTENTERA,valor)
{\t,\n, }
digito

Consideraciones para su implementacin

1) Saltaremos separadores: \t \n
separador
2) Sobre la entrada:
carcter a carcter: buffer de entrada de tamao 1
entrada de stdin
termina con $
no corresponde a ningn lexema
devuelve un token ficticio FIN

3) Usaremos algunas variables globales

Por qu globales?
yytext
string con el lexema reconocido
yylval
entero con informacin necesaria
(valor de las ctes., p.e.)
yyleng
longitud del lexema

Implementacin con TT
#include <stdio.h>
#include <ctype.h> /*isdigit(),isalpha()...*/
typedef int token;
enum{ FIN=0, char sigCar,
MENOR=256, *delante,
MENORIGUAL, yytext[YYLMAX]; /*el lexema*/
MAYOR, int yyleng, /*long. del lexema*/
MAYORIGUAL, yylval; /*para atributos*/
IGUAL, int estado; /*el estado*/
DISTINTO,
IDENTIFICADOR,
CONSTENTERA,
hab., sern
NUMESTADOS=13, 128
NUMCARS=41,
/* 'a'...'z''0'...'9' '<' '>' '=' ' ' OTROS */
ERROR=-1
};
#define carFin '$' /*fin de ent.*/
#define YYLMAX 100

#define PONCAR(pC,C,L)
{sprintf(pC++,"%c",C);L++;}

Las a...z0...9 < > = otros

transi- 0 9 ... 9 11... 11 1 5 8 0 ERR
ciones 1 4 ... 4 4... 4 4 2 3 4 4
.
.
.
. .................
.
.
.
12

Parte
del int T[NUMESTADOS][NUMCARS]={
aut- {9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
9,9,9,9,9,9,11,11,11,11,11,11,11,11,11,
mata 11,1,5,8,0,ERROR},
........
int aceptacion[NUMESTADOS]=
{0,0,1,1,1,0,1,1,1,0,1,0,1};

token yylex()
{ int sigEstado, seguir=1; /* posible nuevo estado */
yyleng=0;
yytext[0]='\0'; /* de momento, lexema vac'io */

delante=yytext;
estado=0;
sigCar=getchar(); gen., no
if(sigCar==carFin) return FIN; necesario
do{
sigEstado=T[estado][pos(sigCar)];
if(sigEstado == ERROR)
seguir=0; saltar
else{ separadores
estado=sigEstado;
if(!isspace(sigCar))
PONCAR(delante, sigCar, yyleng);
if(aceptacion[estado])
seguir=0; ...
else{ sigCar=getchar(); if(aceptacion[estado])
if(sigCar==carFin) return tokenAceptacion();
seguir=0; else if(sigCar==carFin)
} return FIN;
} else
}while(seguir); errorLexico();
... }
Compiladores
} I. C.P.S. Universidad de Zaragoza -J.Ezpeleta- 60
/*-----------------------------------------------
Implementacin
PRE: concon
global 'estado' TTun estado de aceptacin
yyleng,yytext como siempre
POST: tokenAceptacion=token correspondiente.
(lo da el estado)
Adems, ejecuta las acciones asociadas
a los estados de aceptacin
-----------------------------------------------*/ elimina ult.
token tokenAceptacion(){ car. de yytext
switch(estado){
case 2: return DISTINTO;
case 3: return MENORIGUAL;
case 4: yytext[yyleng-1]='\0';
yyleng--;
ungetc(sigCar, stdin);
return MENOR;
case 6: return MAYORIGUAL; case 10: yytext[yyleng-1]='\0';
case 7: yytext[yyleng-1]='\0'; yyleng--;
ungetc(sigCar, stdin);
yyleng--; return IDENTIFICADOR;
ungetc(sigCar, stdin); case 12: yytext[yyleng-1]='\0';
return MAYOR; yyleng--;
case 8: return IGUAL; ungetc(sigCar, stdin);
... sscanf(yytext, "%d", &yylval);
return CONSTENTERA;
}
} valor
entero
El objetivo bsico de una implementacin de un AF es dar la

aplicacin
(estado, carEntrada) sigEstado
La ms natural:
tabla como array
una fila por cada estado
una columna por cada carcter posible de entrada
en general, 128 columnas
Ventajas:
fcil de programar (trivial)
acceso rpido
Inconvenientes:
despilfarro de memoria
Para evitar el problema

de la memoria
tcnicas de compactacin
de tablas
...a b c d...0 1 2 3...
METODO 1: basado en
que muchas ...0 0 ...2 2 2 1...
columnas/filas suelen
ser idnticas
Ejemplo: asumamos 6 0 0
1 1 -1 3 1 -1
estados (S0,...,S5) 2 2 -1 2 1 5
3 3 -1 -1 2 5
4 4 -1 -1 2 -1
5 4 -1 -1 4 -1

METODO 2: especialmente til cuando la matriz de transicin es

muy dispersa
Ejemplo: asumamos 6 estados (S0,...,S5)
4 a 3 . 0 x 5 1 1
0
1 ......
2
3
4 2 $ 0 1 3
5
......

Sobre recuperacin de errores lxicos
Cuando un scanner detecta un error lxico
NO abortar la compilacin + RECUPERAR
panic-mode
Tres aproximaciones:
ignorar los caracteres ledos hasta la deteccin del error
borrar el primer carcter ledo y recomenzar el anlisis
aadir algn carcter (si est claro)
Errores ms comunes: string,..
debidos a un carcter extrao
suelen aparecer al principio del lexema
desbordamiento de variables/constantes
fin de lnea antes de cerrar un string
problemas cerrar/abrir comentarios
Opcionalmente: pasar al analizador sintctico un token de ERROR,
junto con el string que lo forma

2 Analisislexico

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

2 Analisislexico

Transféré par

Droits d'auteur :

Formats disponibles

Leccin 2: Anlisis lxico

1) El papel de un analizador Aceptacin de un string por un

2) Tokens, lexemas y patrones 5) Conversin de una expresin

Compiladores I. C.P.S. Universidad de Zaragoza -J.Ezpeleta- 1

La funcin primordial es agrupar caracteres de la entrada en

Compiladores I. C.P.S. Universidad de Zaragoza -J.Ezpeleta- 2

Compiladores I. C.P.S. Universidad de Zaragoza -J.Ezpeleta- 3

Compiladores I. C.P.S. Universidad de Zaragoza -J.Ezpeleta- 4

Los tokens se pasan como valores simples

Compiladores I. C.P.S. Universidad de Zaragoza -J.Ezpeleta- 5

nombre que se da a cada componente lxico

forma compacta de describir conjuntos de lexemas

Compiladores I. C.P.S. Universidad de Zaragoza -J.Ezpeleta- 7

Compiladores I. C.P.S. Universidad de Zaragoza -J.Ezpeleta- 8

Compiladores I. C.P.S. Universidad de Zaragoza -J.Ezpeleta- 9

Esta informacin, se devuelve mediante atributos

Compiladores I. C.P.S. Universidad de Zaragoza -J.Ezpeleta- 10

Proceso de construccin (con ayuda de herramientas)

c1...cn$ A.L. tktk-1...t1

Compiladores I. C.P.S. Universidad de Zaragoza -J.Ezpeleta- 11

Qu pinta tiene un Pero puede ser complicado:

Compiladores I. C.P.S. Universidad de Zaragoza -J.Ezpeleta- 12

Compiladores I. C.P.S. Universidad de Zaragoza -J.Ezpeleta- 13

longitud de una cadena

Siendo ={0,1} {0,01,011,0111,01111,...}

Compiladores I. C.P.S. Universidad de Zaragoza -J.Ezpeleta- 14

Operadores sobre lenguajes:

cerradura de Kleene cerradura positiva

CERO o MAS concatenaciones UNA o MAS concatenaciones

Compiladores I. C.P.S. Universidad de Zaragoza -J.Ezpeleta- 15

Para un token dado, los lexemas correspondientes los

Una expresin regular r:

Compiladores I. C.P.S. Universidad de Zaragoza -J.Ezpeleta- 16

(r) es la exp. reg. cuyo lenguaje es L(r)

Compiladores I. C.P.S. Universidad de Zaragoza -J.Ezpeleta- 17

expresiones regulares equivalentes

Compiladores I. C.P.S. Universidad de Zaragoza -J.Ezpeleta- 18

Ejemplo 1: Sea ={a,b}

Compiladores I. C.P.S. Universidad de Zaragoza -J.Ezpeleta- 19

Ejemplo 2: Sea ={0,1}

y todos los strings que empiezan con

(0|1)*00(0|1)* todos los strings con al menos 2 0

(0|1)*011 todos los strings que acaban en 011

Compiladores I. C.P.S. Universidad de Zaragoza -J.Ezpeleta- 20

Ya sabemos expresar los lexemas correspondientes a los tokens

Compiladores I. C.P.S. Universidad de Zaragoza -J.Ezpeleta- 21

Los autmatas finitos pueden ser utilizados para reconocer los

Compiladores I. C.P.S. Universidad de Zaragoza -J.Ezpeleta- 22

Autmata Finito No Determinista

Un AFN es una 5-tupla (S,,,s0,F) donde:

Compiladores I. C.P.S. Universidad de Zaragoza -J.Ezpeleta- 23

Compiladores I. C.P.S. Universidad de Zaragoza -J.Ezpeleta- 24

AFN como grafo de transiciones

Cmo funciona un AFN?

aceptacin de un string por un AFN

El string c1c2...cn es aceptado por un AFN

de manera que sm es un estado final (de

Compiladores I. C.P.S. Universidad de Zaragoza -J.Ezpeleta- 26

Compiladores I. C.P.S. Universidad de Zaragoza -J.Ezpeleta- 27

Compiladores I. C.P.S. Universidad de Zaragoza -J.Ezpeleta- 28

Un Autmata Finito Determinista (AFD) es un caso particular de

Un AFD es un AFN tal que:

Compiladores I. C.P.S. Universidad de Zaragoza -J.Ezpeleta- 29

(0|1)00(0|1) todos los strings con al menos 2 0