Академический Документы
Профессиональный Документы
Культура Документы
1. Introduccin
Para iniciar tenemos que contestar las siguientes preguntas:
Qu es un lenguaje de programacin?
1.1
Lenguaje de Programacin
1.1.1.
1.1.2.
en
lenguaje
ensamblador
ldl $3,16($15)
addq $3,1,$4
mull $2,$4,$2
ldl $3,16($15)
addq $3,1,$4
mull $2,$4,$2
stl $2,20($15)
ldl $0,20($15)
br $31,$33
$33:
bis $15,$15,$30
ldq $26,0($30)
ldq $15,8($30)
addq $30,32,$30
4
Detalles
de
ret $31,($26),1
Primeros Lenguajes
(1954 -1957) Fortran
(1958 -1959) LISP
(1958 -1960) Algo60
(1959 -1960) COBOL
Otros Lenguajes
(1972) C
(1986) C++
(1994) Java
Compiladores optimizan cdigo para...
Velocidad / Rendimiento
Tamao de cdigo
Consumo de Poder
Compilacinrpida / eficiente
Seguridad / Confiabilidad
Debugging
Paradigmas
Es el conjunto de ideas, modelos o patrones que forman una percepcin sobre algn
objeto, situacin, cosa persona.
Un cambio de paradigma en la ciencia significa un gran cambio.
Paradigmas de Programacin
Un paradigma de programacin es una propuesta tecnolgica que es adoptada por una comunidad de
programadores cuyo ncleo central es incuestionable en cuanto a que unvocamente trata de resolver
uno o varios problemas claramente delimitados.
La resolucin de estos problemas debe suponer consecuentemente un avance significativo en al menos
un parmetro que afecte a la ingeniera de software. Tiene una estrecha relacin con la formalizacin
de determinados lenguajes en su momento de definicin. Un paradigma de programacin est
delimitado en el tiempo en cuanto a aceptacin y uso ya que nuevos paradigmas aportan nuevas o
mejores soluciones que la sustituyen parcial o totalmente.
Paradigmas de programacin
Programacin imperativa
Programacin lgica
Programacin funcional
Programacin declarativa
Programacin estructurada
Programacin dirigida por eventos
Programacin modular
Programacin orientada a aspectos
Programacin orientada a objetos
Programacin con restricciones
5
Programacin a nivel funcional (John Backus)
Programacin a nivel de valores (John Backus)
Programacin orientada a componentes
1.2
Conceptos Bsicos
1.3
Traductores y Compiladores
Los traductores son programas que traducen los programas en cdigo fuente, escritos en
lenguajes de alto nivel, a programas escritos en lenguaje mquina.
Los traductores pueden ser de dos tipos: compiladores e intrpretes
1.3.2. Interprete
Desventajas
que
permite
modificar
ampliar
Los sistemas interpretados han tenido una gran importancia desde la aparicin de los
primeros ordenadores. En la actualidad, la evolucin del hardware abre nuevas
posibilidades a los sistemas interpretados. La preocupacin ya no es tanto la eficiencia
como la capacidad de desarrollo rpido de nuevas aplicaciones. Las principales
aplicaciones podran resumirse en:
Tipos de intrpretes
Intrpretes puros
Intrpretes avanzados
Intrpretes incrementales
10
1.3.3. Compilador
11
12
Partes de un compilador
Alternativamente, las fases descritas para las tareas de anlisis y sntesis se pueden
agrupar en Front-end y Back-end:
Esta divisin permite que el mismo Back End se utilice para generar el cdigo mquina de
varios lenguajes de programacin distintos y que el mismo Front End que sirve para
analizar el cdigo fuente de un lenguaje de programacin concreto sirva para
generar cdigo mquina en varias plataformas distintas. Suele incluir la generacin y
optimizacin del cdigo dependiente de la mquina.
El cdigo que genera el Back End normalmente no se puede ejecutar directamente, sino
que necesita ser enlazado por un programa enlazador (linker)
Tipos de compiladores
Esta taxonoma de los tipos de compiladores no es excluyente, por lo que puede haber
compiladores que se adscriban a varias categoras:
Compiladores cruzados: generan cdigo para un sistema distinto del que estn
funcionando.
13
Un programa que ha sido compilado puede correr por s slo, pues en el proceso
de compilacin se lo transformo en otro lenguaje (lenguaje mquina).
14
2. Analizador Lxico
2.1
Leer los caracteres de cdigo fuente y formarlos en unidades lgicas para que lo aborden
las partes siguientes de compilador (generalmente el analizador Sintctico). Las unidades
lgicas que genera el analizador lxico se denominan Tokens. Los Tokens son las
palabras de un lenguaje natural: cada tokens es una secuencia de caracteres que
representa una unidad de informacin en el programa fuente.
15
El token de smbolo especial como MAS, no solo se tiene el valor de cadena +, sino
tambin la operacin aritmtica real + que est asociada con l mismo. Es decir el
smbolo del token mismo se puede ver simplemente como otro atributo.
El analizador lxico opera bajo peticin del analizador sintctico devolviendo un
componente lxico conforme el analizador sintctico lo va necesitando para avanzar en la
gramtica. Los componentes lxicos son los smbolos terminales de la gramtica.
Suele implementarse como una subrutina del analizador sintctico. Cuando recibe la
orden obtn el siguiente componente lxico, el analizador lxico lee los caracteres de
entrada hasta identificar el siguiente componente lxico.
17
2.2
Patrn: es una regla que genera la secuencia de caracteres que puede representar a un
determinado componente lxico (una expresin regular).
Lexema: cadena de caracteres que concuerda con un patrn que describe un
componente lxico. Un componente lxico puede tener uno o infinitos lexemas. Por
ejemplo: palabras reservadas tienen un nico lexema. Los nmeros y los identificadores
tienen infinitos lexemas.
Los componentes lxicos se suelen definir como un tipo enumerado. Se codifican como
enteros. Tambin se suele almacenar la cadena de caracteres que se acaba de reconocer
(el lexema), que se usar posteriormente para el anlisis semntico.
TKN_IF, TKN_THEN, TKN_ NUM, TKN_ ID, TNK_ OPADD,...
Es importante conocer el lexema (para construir la tabla de smbolos). Los componentes
lxicos se representan mediante una estructura registro con tipo de token y lexema:
18
2.3
Una expresin regular, a menudo llamada tambin patrn, es una expresin que describe
un conjunto de cadenas sin enumerar sus elementos. Por ejemplo, el grupo formado por
las cadenas Handel, Hndel y Haendel se describe mediante el patrn "H(a||ae)ndel".
La mayora de las formalizaciones proporcionan los siguientes constructores: una
expresin regular es una forma de representar a los lenguajes regulares (finitos o infinitos)
y se construye utilizando caracteres del alfabeto sobre el cual se define el lenguaje.
Especficamente, las expresiones regulares se construyen utilizando los operadores
unin, concatenacin y clausura de Kleene.
Los componentes lxicos se especifican haciendo uso de expresiones regulares. Para ello
hay que conocer las reglas que rigen la creacin de las expresiones regulares
Alternacin
Una barra vertical separa las alternativas. Por ejemplo, "marrn|castao" casa con marrn
o castao.
Cuantificacin
Un cuantificador tras un carcter especifica la frecuencia con la que ste puede ocurrir.
Los cuantificadores ms comunes son +, ? y *:
+ , El signo ms indica que el carcter al que sigue debe aparecer al menos una
vez. Por ejemplo, "ho+la" describe el conjunto infinito hola, hoola, hooola, hoooola,
etctera.
? , El signo de interrogacin indica que el carcter al que sigue puede aparecer
como mucho una vez. Por ejemplo, "ob?scuro" casa con oscuro y obscuro.
, El asterisco indica que el carcter que lo precede puede aparecer cero, una, o
ms veces. Por ejemplo, "0*42" casa con 42, 042, 0042, 00042, etctera.
Agrupacin
Los parntesis pueden usarse para definir el mbito y precedencia de los dems
operadores. Por ejemplo, "(p|m)adre" es lo mismo que "padre|madre", y "(des)?amor"
casa con amor y con desamor.
Los constructores pueden combinarse libremente dentro de la misma expresin, por lo
que "H(ae?|)ndel" equivale a "H(a|ae|)ndel".
La sintaxis precisa de las expresiones regulares cambia segn las herramientas y
aplicaciones consideradas, y se describe con ms detalle a continuacin.
Su utilidad ms obvia es la de describir un conjunto de cadenas, lo que resulta de utilidad
en editores de texto y aplicaciones para buscar y manipular textos. Muchos lenguajes de
programacin admiten el uso de expresiones regulares con este fin.
19
El Punto "."
El punto es interpretado por el motor de bsqueda como cualquier otro carcter excepto
los caracteres que representan un salto de lnea, a menos que se le especifique esto al
motor de Expresiones Regulares. Por lo tanto si esta opcin se deshabilita en el motor de
bsqueda que se utilice, el punto le dir al motor que encuentre cualquier carcter
incluyendo los saltos de lnea. En la herramienta EditPad Pro esto se hace por medio de
la opcin "punto corresponde a nueva lnea" en las opciones de bsqueda. En .Net
Framework se utiliza la opcin RegexOptions. Singleline al efectuar la bsqueda o crear la
expresin regular.
El punto se utiliza de la siguiente forma: Si se le dice al motor de RegEx que busque
"g.t" en la cadena "el gato de piedra en la gtica puerta de getisborogoot" el motor
de bsqueda encontrar "gat", "gt" y por ltimo "get". Ntese que el motor de
bsqueda no encuentra "goot"; esto es porque el punto representa un solo carcter y
nicamente uno. Si es necesario que el motor encuentra tambin la expresin "goot", ser
necesario utilizar repeticiones, las cuales se explican ms adelante.
Aunque el punto es muy til para encontrar caracteres que no conocemos, es necesario
recordar que corresponde a cualquier carcter y que muchas veces esto no es lo que se
requiere. Es muy diferente buscar cualquier carcter que buscar cualquier carcter
alfanumrico o cualquier dgito o cualquier no-dgito o cualquier no-alfanumrico. Se debe
tomar esto en cuenta antes de utilizar el punto y obtener resultados no deseados
20
\t Representa un tabulador.
\r Representa el "retorno de carro" o "regreso al inicio" o sea el lugar en
que la lnea vuelve a iniciar.
\n Representa la "nueva lnea" el carcter por medio del cual una lnea da
inicio. Es necesario recordar que en Windows es necesaria una combinacin
de \r\n para comenzar una nueva lnea, mientras que en Unix solamente se
usa \n.
\a Representa una "campana" o "beep" que se produce al imprimir este
carcter.
\e Representa la tecla "Esc" o "Escape"
\f Representa un salto de pgina
\v Representa un tabulador vertical
\x Se utiliza para representar caracteres ASCII o ANSI si conoce su cdigo.
De esta forma, si se busca el smbolo de derechos de autor y la fuente en la
que se busca utiliza el conjunto de caracteres Latin-1 es posible encontrarlo
utilizando "\xA9".
\u Se utiliza para representar caracteres Unicode si se conoce su cdigo.
"\u00A2" representa el smbolo de centavos. No todos los motores de
Expresiones Regulares soportan Unicode. El .Net Framework lo hace, pero el
EditPad Pro no, por ejemplo.
\d Representa un dgito del 0 al 9.
\w Representa cualquier carcter alfanumrico.
\s Representa un espacio en blanco.
\D Representa cualquier carcter que no sea un dgito del 0 al 9.
\W Representa cualquier carcter no alfanumrico.
\S Representa cualquier carcter que no sea un espacio en blanco.
\A Representa el inicio de la cadena. No un carcter sino una posicin.
\Z Representa el final de la cadena. No un carcter sino una posicin.
\b Marca el inicio y el final de una palabra.
\B Marca la posicin entre dos caracteres alfanumricos o dos noalfanumricos.
necesario antecederlo con la barra inversa. El nico carcter que es necesario anteceder
con la barra inversa dentro de los corchetes es la propia barra inversa. La expresin
regular "[\dA-Fa-f]" nos permite encontrar dgitos hexadecimales. Los corchetes nos
permiten tambin encontrar palabras an si estn escritas de forma errnea, por ejemplo,
la expresin regular "expresi[o]n" permite encontrar en un texto la palabra "expresin"
aunque se haya escrito con o sin tilde. Es necesario aclarar que sin importar cuantos
caracteres se introduzcan dentro del grupo por medio de los corchetes, el grupo slo le
dice al motor de bsqueda que encuentre un solo carcter a la vez, es decir, que
"expresi[o]n" no encontrar "expresioon" o "expresion".
La barra "|"
Sirve para indicar una de varias opciones. Por ejemplo, la expresin regular "a|e"
encontrar cualquier "a" o "e" dentro del texto. La expresin regular "este|oeste|norte|sur"
permitir encontrar cualquiera de los nombres de los puntos cardinales. La barra se utiliza
comnmente en conjunto con otros caracteres especiales.
El signo de dlar "$"
Este carcter tiene una doble funcionalidad, que difiere cuando se utiliza
individualmente y cuando se utiliza en conjunto con otros caracteres especiales. En
primer lugar su funcionalidad como carcter individual: el carcter "^" representa el
inicio de la cadena (de la misma forma que el signo de dlar "$" representa el final
de la cadena). Por tanto, si se utiliza la expresin regular "^[a-z]" el motor encontrar
todos los prrafos que den inicio con una letra minscula. Cuando se utiliza en conjunto
con los corchetes de la siguiente forma "[^\w ]" permite encontrar cualquier carcter que
NO se encuentre dentro del grupo indicado. La expresin indicada permite encontrar, por
ejemplo, cualquier carcter que no sea alfanumrico o un espacio, es decir, busca todos
los smbolos de puntuacin y dems caracteres especiales.
La utilizacin en conjunto de los caracteres especiales "^" y "$" permite realizar
validaciones en forma sencilla. Por ejemplo "^\d$" permite asegurar que la cadena a
verificar representa un nico dgito, "^\d\d/\d\d/\d\d\d\d$" permite validar una fecha en
formato corto, aunque no permite verificar si es una fecha vlida, ya que 99/99/9999
tambin sera vlido en este formato; la validacin completa de una fecha tambin es
posible mediante expresiones regulares, como se ejemplifica ms adelante.
De forma similar que los corchetes, los parntesis sirven para agrupar caracteres, sin
embargo existen varias diferencias fundamentales entre los grupos establecidos por
medio de corchetes y los grupos establecidos por parntesis:
22
El signo de pregunta tiene varias funciones dentro del lenguaje de las expresiones
regulares. La primera de ellas es especificar que una parte de la bsqueda es opcional.
Por ejemplo, la expresin regular "ob?scuridad" permite encontrar tanto "oscuridad" como
"obscuridad". En conjunto con los parentesis redondos permite especificar que un
conjunto mayor de caracteres es opcional; por ejemplo "Nov(\.|iembre|ember)?" permite
encontrar tanto "Nov" como "Nov.", "Noviembre" y "November". Como se mencion
anteriormente los parntesis nos permiten establecer un "punto de referencia" para el
motor de bsqueda, sin embargo, algunas veces, no se desea utilizarlos con este
propsito, como en el ejemplo anterior "Nov(\.|iembre|ember)?". En este caso el
establecimiento de este punto de referencia (que se detalla ms adelante) representa una
inversin intil de recursos por parte del motor de bsqueda. Para evitar se puede utilizar
el signo de pregunta de la siguiente forma: "Nov(?:\.|iembre|ember)?". Aunque el resultado
obtenido ser el mismo, el motor de bsqueda no realizar una inversin intil de recursos
en este grupo, sino que lo ignorar. Cuando no sea necesario reutilizar el grupo, es
aconsejable utilizar este formato. De forma similar, es posible utilizar el signo de pregunta
con otro significado: Los parntesis definen grupos "annimos", sin embargo el signo de
pregunta en conjunto con los parntesis triangulares "<>" permite "nombrar" estos grupos
de la siguiente forma: "^(?<Da>\d\d)/(?<Mes>\d\d)/(?<Ao>\d\d\d\d)$"; Con lo cual se le
especifica al motor de bsqueda que los primeros dos dgitos encontrados llevarn la
etiqueta "Da", los segundos la etiqueta "Mes" y los ltimos cuatro dgitos llevarn la
etiqueta "Ao".
Nota: a pesar de la complejidad y flexibilidad dada por los caracteres especiales
estudiados hasta ahora, en su mayora nos permiten encontrar solamente un carcter a la
vez, o un grupo de caracteres a la vez. Los metacaracteres enumerados en adelante
permiten establecer repeticiones.
Las llaves "{}
Comnmente las llaves son caracteres literales cuando se utilizan por separado en una
expresin regular. Para que adquieran su funcin de metacaracteres es necesario que
encierren uno o varios nmeros separados por coma y que estn colocados a la derecha
de otra expresin regular de la siguiente forma: "\d{2}" Esta expresin le dice al motor de
bsqueda que encuentre dos dgitos contiguos. Utilizando esta frmula podramos
convertir el ejemplo "^\d\d/\d\d/\d\d\d\d$" que serva para validar un formato de fecha en
"^\d{2}/\d{2}/\d{4}$" para una mayor claridad en la lectura de la expresin.
23
Nota: aunque esta forma de encontrar elementos repetidos es muy til, algunas veces no
se conoce con claridad cuantas veces se repite lo que se busca o su grado de repeticin
es variable. En estos casos los siguientes metacaracteres son tiles.
El asterisco "*
El asterisco sirve para encontrar algo que se encuentra repetido 0 o ms veces. Por
ejemplo, utilizando la expresin "[a-zA-Z]\d*" ser posible encontrar tanto "H" como "H1",
"H01", "H100" y "H1000", es decir, una letra seguida de un nmero indefinido de dgitos.
Es necesario tener cuidado con el comportamiento del asterisco, ya que este por defecto
trata de encontrar la mayor cantidad posible de caracteres que correspondan con el
patrn que se busca. De esta forma si se utiliza "\(.*\)" para encontrar cualquier cadena
que se encuentre entre parntesis y se lo aplica sobre el texto "Ver (Fig. 1) y (Fig. 2)" se
esperara que el motor de bsqueda encuentre los textos "(Fig. 1)" y "(Fig. 2)", sin
embargo, debido a esta caracterstica, en su lugar encontrar el texto "(Fig. 1) y (Fig. 2)".
Esto sucede porque el asterisco le dice al motor de bsqueda que llene todos los
espacios posibles entre dos parntesis. Para obtener el resultado deseado se debe utilizar
el asterisco en conjunto con el signo de pregunta de la siguiente forma: "\(.*?\)" Esto es
equivalente a decirle al motor de bsqueda que "Encuentre un parntesis de apertura y
luego encuentre cualquier carcter repetido hasta que encuentre un parntesis de cierre".
Expresiones regulares
Patrn
Significado
exp_reg
match
Cadenas
cualquier
carcter
excepto
EOL
("nueva lnea")
"."
carcter
especial
"\*"
"\\"
"*"
"\"
un carcter
"a
"A
"2"
"a"
"A"
"2"
xyz
varios
caracteres
"hola"
"hola"
x|y
un
"a|b"
"a" o "b"
carcter
24
otro
[xyz]
un carcter que
est en una lista
"[aeiou]"
una vocal
[a-z]
un carcter que
pertenezca a un
rango
"[a-z]
[a-zA-Z]
"[a-z][A-Z]"
una minscula
una letra
una minscula seguida de una mayscula
[x]
cualquier
carcter
excepto "x"
"[a]"
[xyz]
un carcter que
no est en una
lista
"[aeiou]"
una consonante
[a-z]
un carcter que
no pertenezca a
un rango
"[a-z]"
una mayscula
\w
cualquier
carcter
alfanumrico
incluyendo
el
guin bajo
equivale a [a-zA-Z0-9_]
\W
cualquier
carcter
no
alfanumrico
equivale a [a-zA-Z0-9_]
\d
cualquier dgito
equivale a [0-9]
\D
cualquier
carcter
dgito
equivale a [0-9]
\t
tabulador
\r
retorno de carro
\n
final de lnea
\s
cualquier
carcter
no
visible,
como
tabulador,
retorno
o
espacio
\S
cualquier
carcter visible
case insensitive,
con
este
modificador no
distinguir entre
maysculas
y
minsculas
no
"/una/i"
25
global,
este
modificador se
usa para que no
se detenga un
proceso
de
sustitucin
al
encontrar
la
primera
ocurrencia
"/a/g"
(xyz)
recuerda
el
patrn para su
posterior
utilizacin con
multiplicadores
o referencias
"(x).(ab)"
comienzo de lnea
"a"
"[aeiou]"
"hola"
final de lnea
"a$"
"[aeiou]$"
"hola$"
"$"
\b
"\bola"
"hola*"
"hol(as)*"
"[a-z]*"
"hola+"
"hol(as)+"
"hola?"
"hol(a)?"
"hol", "hola"
"hol", "holas"
{n}
"a{3}"
"(as){3}"
"aaa"
"asasas"
{n,m}
"a{2,4}"
"(as){2,4}"
26
{n,}
"a{2,}"
"(as){2,}"
Algunos Ejemplos
Nmeros
nat = [0-9]+
signedNat = ( +| -)? nat
number = signedNat(.nat)? (E signedNat)?
Identificadores
letter = [a-zA-Z]
digit = [0-9]
identifier = letter (letter | digit)*
Palabras Reservadas
Tkn_ if = if
tkn _while = while
tkn _do = do
2.3.1
Definicin Regular
2.3.2
2.3.3
Tratamiento de errores
Ejemplos
a) Sea el vocabulario {a,b} y la expresin regular aa*bb*. Indicar el lenguaje que
denota, y algunas cadenas de dicho lenguaje.
Solucin: Algunas cadenas son:
ab
aab
aaaab
abbbb
abb
aaaab
El lenguaje que se describe es L={cadenas que comienzan por una a y continan
con varias o ninguna a, y siguen con una b y continuan con varias o ninguna b}
aaa
bbb
aba
abaaa
abbaa
2.3.4
Ejercicios
29
2.4
Autmatas
Un autmata es una construccin lgica que recibe una entrada y produce una salida en
funcin de todo lo recibido hasta ese instante.
En el caso de los Procesadores de Lenguaje un autmata es una construccin lgica que
recibe como entrada una cadena de smbolos y produce una salida indicando si dicha
cadena pertenece o no a un determinado lenguaje.
2.4.1
Representacin de autmatas
Tabla de transiciones
Las funciones f y g pueden representarse mediante una tabla, con tantas filas como
estados y tantas columnas como entradas. As por ejemplo se puede representar el
autmata A = ( E, S, Q, f, g ) donde E = {a,b}, S = {0,1}, Q = {q1, q2, q3} y las funciones f y
g se pueden representar por :
30
2.4.2.2
Diagramas de Moore
Los diagramas de Moore son otra forma de representar las funciones de transicin y
salida de un autmata.
El diagrama de Moore es un grafo orientado en el que cada nodo corresponde a un
estado
Ms ejemplos
32
2.4.3
Lenguaje Generado
El lenguaje generado se obtiene partiendo del estado inicial y recorriendo todos los
caminos posibles para alcanzar el estado final. As se obtiene que este autmata
reconoce el lenguaje :
LA1 = abaababbbaabb
La expresin regular que denota el lenguaje es a+b+ o tambin aa*bb*.
L(A1) = {anbm/n 1m 1}
2.4.4
2.4.5
34
2.4.6
Expresin regular
35
Expresin regular a
Expresin regular a*
Expresin regular a+
Expresin regular a b
36
37
38
39
40
41
42
String matching
43
44
45
46
b
{q0,q1}
{q1}
dado que tomando en cuenta que estamos
llegamos a los estado {qo,q1} a la vez por
Para poder eliminar esa ambigedad (convertir un AFND a AFD ) , iniciamos en el estado
inicial q0 y elaboramos la nueva tabla de transicin :
Observando el autmata dado inicialmente, estamos en el estado q0 e ingresa a nos
lleva al estado q0 , pero si ingresa b nos lleva a q0 y q1 a la vez
a
{q0} {q0}
b
{q0,q1}
Con esta porcin de tabla de transicin elaborada nos damos cuenta que ha aparecido un
nuevo estado {q0,q1} , por ello colocamos en el lugar de los estado a este estado
encontrado.
a
q0
{q0}
{q0,q1} {q0}
b
{q0,q1}
{q0,q1}
a
1
b
2
48
Ejercicios
1. Sea M = (Q, , , q0, F) un AFD con Q = {q0 ,q1 ,q2 }, = {a, b}, F = {q2} y la
funcin de transicin :
a) Dibuja el autmata M
b) Traza los cmputos de M que procesan las palabras abaa, bbbabb, babababbbaa
c) Qu palabras de las procesadas en (b) son aceptadas por M?
2. Busca tres palabras aceptadas y tres palabras rechazadas por cada uno de los
siguientes autmatas mostrando el cmputo que las procesa. Determina cules de
ellos estn totalmente especificados. Sabras cul es el lenguaje aceptado por
cada uno de ellos?
49
3. Construye AFDs que acepten cada uno de los siguientes lenguajes definidos
sobre el alfabeto = {a,b}:
a ) L = { x * : la longitud de x es divisible por 3}
b ) L = { x *: aba no es subpalabra de x }
c ) L = { x * : x comienza por a y termina por ab }
d ) L = { x * : x tiene un nmero par de a's y un nmero par de b's }
e ) L = { x * : x tiene tres a's consecutivas }
f ) L = { x * : toda aparicin de la subpalabra aba en x, o bien va seguida de bb, o
est al final de la palabra }
g ) L = { x * : si x empieza por a no contiene la subpalabra aa y si x empieza por b
contiene la subpalabra aa }
h ) L = { x * : x tiene un nmero par de apariciones de la cadena ab }
50
51
3. Analizador Sintctico
Antes de continuar veamos algunas tems importantes del analizador lxico (expresiones
regulares, gramticas y lenguajes)
Una expresin regular puede ser escrita usando:
Caracteres en el alfabeto
Ejemplo:
(-| ) (0|1|2|3|4|5|6|7|8|9)+ (. (0|1|2|3|4|5|6|7|8|9)*)?
Ejemplo:
num = 0|1|2|3|4|5|6|7|8|9
posint = num num*
int = ( | -) posint
real = int ( | (. posint))
Ejemplo:
(-| ) (0|1|2|3|4|5|6|7|8|9)+ (. (0|1|2|3|4|5|6|7|8|9)*)?
Algoritmo de transformacin
3.1
Sintaxis
Como se ve un programa
Semntica
3.2
3.3
53
Cdigo en Assembler
3.4
El anlisis sintctico se puede considerar como una funcin que toma como entrada la
secuencia de componentes lxicos producida por el anlisis lxico y produce como salida
el rbol sintctico.
En la realidad, el anlisis sintctico hace una peticin al anlisis lxico del componente
lxico siguiente en la entrada (los smbolos terminales) conforme lo va necesitando en el
proceso de anlisis, conforme se mueve a lo largo de la gramtica.
3.5
3.6
G = {S, VT , VNT , P}
S: el axioma o smbolo de inicio
VT : conjunto de terminales, los componentes lxicos
VNT : conjunto de no-terminales
P: conjunto de reglas de produccin de la forma
VNT X1; : : : ;Xn; con Xi pertenece (VT U VNT )
Expresiones regulares o gramticas independientes del contexto?
Las expresiones regulares no permiten construcciones anidadas tan comunes en los
lenguajes de programacin: parntesis equilibrados, concordancia de pares de palabras
clave como begin-end,
do-while, ...
Por ejemplo: consideremos el problema de los parntesis equilibrados en una expresin
aritmtica. El hecho de que haya un parntesis abierto obliga a que haya un parntesis
cerrado. Este problema es similar a considerar el lenguaje
L = {aba; aabaa; aaabaaa; : : : ; } = {anban <= 0}
Si intentamos escribir una expresin regular, lo ms prximo seria: {a*ba*} pero no se
garantiza que el nmero de a's antes y despus sea el mismo.
Las expresiones regulares NO SABEN contar. NO es posible especificar la estructura
de un lenguaje de programacin con slo expresiones regulares.
Como tenemos el problema de las parntesis balanceados o las llaves balanceadas
segn sea el lenguaje que usamos, tenemos que tener en cuenta :
Nmero de parntesis abiertos debe ser igual a nmero de parntesis cerrados
Necesitamos mantener un conteo o necesitamos recursin
Adems: NFAs y DFAs no pueden ejecutar conteo sin lmites
Hay alguna gramtica que defina esto?
<S> ( <S> ) <S> |
La definicin es recursiva
Esta es una gramtica libre de contexto
Es ms expresiva que las expresiones regulares
55
3.7
Ejercicios
Convertir las siguientes ER en CFGs
a) (a|b)*
b) xy*a+
c) (ab)+c?
57
3.8
La forma en que los terminales y no-terminales son combinados para formar strings
Un no-terminal en el lado izquierdo (LHS) y un string de terminales y no-terminales en el
lado derecho (RHS)
Teniendo en cuenta todos los elementos que componen una CFGs (Gramticas libres de contexto)
hace posible la creacin de arboles de derivacin que proporcionan una herramienta para hacer
posible la creacin de arboles de analizador sintctico (Parser).
La interseccin entre el vocabulario terminal y no terminal es el conjunto vaco:
{VN} {VT} = {vaco}
La unin entre el vocabulario terminal y no terminal es el vocabulario:
{VN} U {VT} = {V}
En ocasiones es importante distinguir si un determinado vocabulario incluye o no la cadena vaca,
indicndose respectivamente con superndice + o superndice *, tal como se muestra a
continuacin:
V+ = V {}
V* = V + {}
Por ejemplo para la gramtica:
E --> id | num | E + E | ( E ) | - E
Donde podemos reconocer los siguientes elementos que componen la gramtica:
Smbolo de inicio: E
No Terminales: E
Terminales: id , num , + , ( , ) , Producciones:
58
E id
E num
EE+E
E(E)
E-E
Otro ejemplo
1. <S> ( <S> ) <S> |
2. <S> ( <S> ) <S>
<S>
En este punto podemos definir algunos elementos terminales como lo son : (,), ; porque
estos smbolos no pueden llevarnos a crear produccin alguna.
Y tambin nos pueden dar los elementos no terminales como es
<S> .
<S>
<S>
Expresin Regular
<A> a
59
p|q
<S> <P>
<S> <Q>
p*
???
Ejemplo 1
Aqu hay una gramtica libre de contexto para expresiones enteras algebraicas
sintcticamente correctas sobre las variables x, y y z:
S x | y | z | S + S | S - S | S *S | S/S | (S)
Generara, por ejemplo, la cadena (x + y) *x - z *y / (x + x)
Ejemplo 2
1) Sea la gramtica: G = ( VT, VN, S, P) donde VT = {a, b}, VN = {S}, y el conjunto de
producciones es:
S ab
S aSb
2) Sea la gramtica G = (VN, VT, S, P) donde :
VN = { <nmero> , <dgito> }
VT = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
S = <nmero>
Las reglas de produccin P son :
<nmero> -> <dgito> <nmero>
60
<nmero> -><dgito>
<dgito> -> 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
Entonces por qu usar expresiones regulares?
8.2 + 35.6
8.32 + 86 * 45.3
(6.001 + 6.004) * (6.035 * -(6.042 + 6.046))
Terminales (o tokens)
Identificando Terminales
<expr> <expr> <op> <expr>
<expr> ( <expr> )
<expr> - <expr>
<expr> num
<op> +
<op> *
61
Producciones
<expr> <expr> <op> <expr>
<expr> ( <expr> )
<expr> - <expr>
Producciones
<expr> num
<op> +
<op> *
62
3.9
Ejemplo de Derivacin
Gramtica
<expr> <expr><op><expr> | (<expr>) | -<expr> | num
<op> + | *
Entrada
36 * ( 8 + 23.4)
63
Token Stream
num * ( num + num )
<expr>
num * <expr>
num * ( <expr> )
64
Otro ejemplo
num * ( num + num )
<expr>
<expr>
num
<op>
<expr>
<expr>
<expr> <op>
num
)
<expr>
num
Left-most derivation
<expr>
<expr> <op> <expr>
num <op> <expr>
num * <expr>
num * ( <expr> )
num * ( <expr> <op> <expr> )
num * ( num <op> <expr> )
num * ( num + <expr> )
num * ( num + num )
Right-most derivation
num * ( num + num )
<expr> * ( num + num )
<expr> <op> ( num + num )
<expr> <op> ( <expr> + num )
<expr> <op> ( <expr> <op> num )
<expr> <op> ( <expr> <op> <expr> )
<expr> <op> ( <expr> )
<expr> <op> <expr>
<expr>
Podriamos obtener : 124 + (23.5 * 86) = 2145 (124 + 23.5) * 86 = 12685 , pero cual
seria la respuesta correcta para la operacin planteada?
El significado semntico es DIFERENTE. No existe una nica traduccin posible. Se
genera cdigo diferente.
No existe un algoritmo que determine con certeza en un plazo finito de tiempo si una
gramtica es ambigua o no. A lo sumo que se ha llegado en el estudio de la ambigedad
es que hay algunas condiciones que de cumplirse determinan la ambigedad, pero en el
caso de no cumplirse no se puede decir que la gramtica es no ambigua.
Necesidad de evitar las gramticas ambiguas. Cmo? transformando la gramtica o
estableciendo precedencias entre operadores y de asociatividad.
67
68
Ejercicios
1.
69
Dnde estamos?
Qu es la semntica de un programa?
Sintxis
70
Cmo se ve un programa
Semntica
71
4.1
un fragmento de codigo
72
Las gramaticas de atributos se suelen escribir en forma tabular, con una parte donde
aparecen las producciones y otra donde aparecen las reglas semanticas (o ecuaciones de
atributos) que permiten calcular los atributos.
Nota: Si un smbolo aparece mas de una vez en una produccin, entonces cada aparicion
debe ser distinguida de las otras apariciones, para que los diferentes valores de las
ocurrencias sean distinguidos.
73
Los atributos se colocan al lado de los nodos del arbol de anlisis sintctico y se dibujan
las dependencias entre ellos. Una echa que va desde los atributos que aparecen en la
parte derecha de la ecuacion hacia el del lado izquierdo. Por ejemplo, para la entrada
(4-3)*2, el arbol sera:
Las reglas semanticas para el clculo de este atributo seran: Para la entrada float x,y, el
arbol de anlisis sintctico con los atributos es:
74
4.2
La Tabla de Smbolos
75
Como ya se dijo en el esbozo la tabla de smbolos es una estructura de datos que se crea
en tiempo de traduccin del programa fuente. Es como un diccionario variable, debe darle
apoyo a la insercin, bsqueda y cancelacin de nombres (identificadores) con sus
atributos asociados, representando las vinculaciones con las declaraciones. Debe
76
tamao mximo o rango de cada una de las dimensiones de los array, si tiene
dimension estatica.
etc..
4.3
Cada camino de salida (exit path) retorna un valor del tipo correcto (ejem return)
77
4.4
Chequeos de Unicidad
4.5
Chequeos de Tipo
Un comprobador de tipos tiene como funcin asegurar que el tipo de una construccin
coincida con el previsto en el contexto. Por eje.: llamada a una funcin con argumentos
adecuados, indexacin de solo variables denidas como matrices.
La comprobacin de tipos se puede realizar junto con el proceso de anlisis sintctico en
la mayora de lenguajes.
El diseo de un comprobador de tipos se basa en informacin acerca de las
construcciones sintcticas del lenguaje, la nocin de tipos y las reglas para asignar tipos
a las construcciones del lenguaje.
78
4.6
Arboles AST
Supongamos, por ejemplo, que nuestro lenguaje permite asignaciones segn la regla
(Asignacin) -> id:=Expresin ;
Es habitual que se impongan ciertas restricciones. En nuestro caso, estas podran ser:
El analizador semntico deber comprobar que estas dos restricciones se cumplen antes
de declarar que la sentencia de asignacin est bien formada. Pero sucede que la
informacin necesaria para comprobarlas es til tambin para generar cdigo. Esto
quiere decir que si tuviramos una separacin estricta entre las fases del compilador,
para generar cdigo deberamos volver a mirar el identificador para saber a qu objeto
(variable, funcin, constante, etc.) corresponde y que tipo tiene y tambin deberamos
volver a comprobar los tipos de la expresin para generar el cdigo adecuado.
Por otro lado, aunque en teora el rbol de anlisis sera suficiente para fases
posteriores de la compilacin o interpretacin, es una representacin que contiene
mucha informacin redundante.
79
El segundo rbol se conoce como rbol de sintaxis abstracta (o AST, de las iniciales en
ingles).
Como hemos comentado, durante el anlisis semntico se recoge una serie de
informaciones que resultan de utilidad para fases posteriores. Estas informaciones se
pueden almacenar en el rbol, decorndolo:
80
Comprobaciones semnticas
Los atributos nos permitirn llevar a cabo las comprobaciones semnticas que necesite el
lenguaje.
81
La tabla de smbolos
Durante la construccin del AST, las comprobaciones semnticas y, probablemente,
durante la interpretacin y la generacin de cdigo necesitaremos obtener informacin
asociada a los distintos identificadores presentes en el programa. La estructura de datos
que permite almacenar y recuperar esta informacin es la tabla de smbolos.
En principio, la tabla debe ofrecer operaciones para:
La implementacin habitual es una tabla que asocia cada identificador a informacin tal
como su naturaleza (constante, variable, nombre de funcin, etc.), su tipo (entero, real,
booleano, etc.), su valor (en el caso de constantes), su direccin (en el caso de variables
y funciones), etc.
Es importante tener nicamente una tabla; si tenemos varias, por ejemplo, una para
constantes y otra para variables, el acceso se hace ms difcil ya que para comprobar las
propiedades de un identificador hay que hacer varias consultas en lugar de una.
Una cuestin importante es como se relacionan la tabla y el AST. Tenemos distintas
posibilidades, que explicaremos sobre el siguiente rbol, correspondiente a la sentencia
a= a+c:
82
La primera posibilidad es dejar el rbol tal cual y cada vez que necesitemos alguna
informacin, por ejemplo el valor de a, consultar la tabla. Esta opcin seria la ms
adecuada para situaciones en las que se vaya a recorrer el rbol pocas veces, por
ejemplo en una calculadora donde se evalu cada expresin una sola vez.
Otra posibilidad es ir decorando cada una de las hojas con toda la informacin que se
vaya recopilando. Por ejemplo, si durante el anlisis averiguamos el tipo y direccin de las
variables, pasaramos a almacenar la nueva informacin:
Equivalencia de tipos
typedef int b;
son equivalentes a y b? La respuesta depende del lenguaje. Existen dos criterios para la
equivalencia:
Hay argumentos a favor de uno y otro criterio. En cualquier caso, hay que tener en cuenta
que para comprobar la equivalencia estructural ya no sirve el mtodo trivial presentado
antes. En este caso, puede haber ciclos, lo que obliga a utilizar algoritmos ms
complicados.
Para comprobar los tipos en las expresiones podemos utilizar un atributo que indique el
tipo de la expresin. Este tipo se infiere a partir de los distintos componentes de la
expresin y de las reglas de tipos del lenguaje.
84
4.7
Solo nos hemos centrado en las comprobaciones de tipo. Las otras son en cierto modo
rutinarias y se pueden realizar fcilmente insertando acciones intercaladas en el cdigo
para realizarlas, por ejem. C uando se introduce un identicador en la Tabla de Smbolos.
85
86
Contenido
1.
Introduccin ............................................................................................................................... 2
1.1
1.1.1.
1.1.2.
1.2
Conceptos Basicos........................................................................................................... 6
1.3
2.2
2.3
Alternacin ............................................................................................................................... 19
Cuantificacin .......................................................................................................................... 19
Agrupacin............................................................................................................................... 19
El Punto "."............................................................................................................................... 20
La barra inversa o contrabarra "" ......................................................................................... 20
Los corchetes "[ ]"................................................................................................................... 21
La barra "|" ............................................................................................................................... 22
El signo de dlar "$" ............................................................................................................... 22
El acento circunflejo "^ ......................................................................................................... 22
Los parntesis "() .................................................................................................................. 22
El signo de interrogacin "?" ................................................................................................. 23
Las llaves "{}........................................................................................................................... 23
El asterisco "* ......................................................................................................................... 24
El signo de suma "+" .............................................................................................................. 24
87
2.3.2
2.3.3
2.3.4
Ejercicios .................................................................................................................. 28
2.4
Autmatas ........................................................................................................................ 30
2.4.1
2.4.2
Representacin de autmatas.............................................................................. 30
2.4.3
Lenguaje Generado................................................................................................ 33
2.4.4
2.4.5
2.4.6
Analizador Sintctico.............................................................................................................. 52
3.1
3.2
3.3
3.4
3.5
3.6
3.7
3.8
Los lenguajes regulares son un subconjunto de los lenguajes libres de contexto ...... 59
3.9
3.10
3.11
4.
4.2
4.4
4.5
4.6
4.7
Ren
Snche
z Vera
89
Firmado digitalmente
por Ren Snchez Vera
Nombre de
reconocimiento (DN):
cn=Ren Snchez Vera,
o=IST La Recoleta,
ou=Informatica,
email=rene.sanchez.ver
a@gmail.com, c=PE
Fecha: 2014.08.20
22:06:57 -05'00'