Unidad 1: Introducción a

la
Teoría de Lenguajes
Formales
David Hernández Escárcega 17410414

Instituto Tecnológico de Parral

Ingeniería en Sistemas Computacionales

Lenguajes y autómatas 1
Contenido
Introducción.......................................................................................................................................2
1.1 Alfabeto........................................................................................................................................2
1.2 Cadenas........................................................................................................................................2
Longitud de cadena........................................................................................................................2
Cadena Vacía..................................................................................................................................2
Concatenación de cadenas.............................................................................................................2
1.3 Lenguajes.....................................................................................................................................3
1.4 Tipos de lenguajes........................................................................................................................3
Lenguaje maquina..........................................................................................................................3
Lenguaje ensamblador...................................................................................................................3
Lenguajes de alto nivel...................................................................................................................3
Lenguaje declarativo......................................................................................................................4
1.5 Herramientas computacionales ligadas con lenguajes.................................................................4
Traductor........................................................................................................................................4
Compilador.....................................................................................................................................4
Ensambladores...............................................................................................................................4
Interpretes.....................................................................................................................................4
1.6 Estructura de un traductor...........................................................................................................4
Fase de análisis...............................................................................................................................4
Fase de síntesis...............................................................................................................................5
1.7 Fases de un compilador................................................................................................................5
Análisis...........................................................................................................................................5
Análisis léxico.............................................................................................................................5
Análisis sintáctico.......................................................................................................................5
Análisis semántico......................................................................................................................5
Síntesis...........................................................................................................................................5
Generación de código intermedio..............................................................................................5
Generación de código objeto.....................................................................................................6
Optimización..............................................................................................................................6
La tabla de símbolos.......................................................................................................................6
Conclusión..........................................................................................................................................6
Bibliografía.........................................................................................................................................7
Introducción.
En los últimos años se han dado una gran cantidad de avances tecnológicos, cada
vez se hace mas uso de computadoras o dispositivos móviles, cada vez se
interactúa mas con programas o aplicaciones que van desde aplicaciones
profesionales a inclusive aplicaciones de entretenimiento. El mercado para el
software se ha vuelto muy amplio y cada día los usuarios son mas exigentes, esto
implica que haya una mayor cantidad de desarrolladores creando estas
aplicaciones, es por esto que cada vez se requieren de herramientas que hagan
más comprensible y fácil la interacción de un usuario con la máquina. Hace unos
años esto era sumamente difícil ya que el desarrollador requería hacer esa
comunicación manualmente debido a la falta de herramientas que automatizaran
ese trabajo lo cual lo hacia un trabajo tedioso, difícil y largo, sin embargo, a día de
hoy existen una gran cantidad de herramientas que nos ayudan a esto y a parte de
esto contando con mejoras que nos ayudan a que el desarrollo sea mucho más
fácil y rápido.

1.1 Alfabeto
Alfabeto es cualquier conjunto finito y no vacío de elementos que denominan
símbolos y los denotaran con el símbolo Ʃ.

1.2 Cadenas
Es una cadena sobre un alfabeto Σ. Puede existir una única cadena que no tiene
símbolos, la cual se denomina cadena vacía y se denota con λ. la cadena vacía
desempeña un papel similar al que desempeña el conjunto vacío Ø en
la teoría de conjuntos.

Longitud de cadena
La longitud de cadena es el número de símbolos que contiene dicha cadena.
ejemplo: la cadena abcb = 4.

Cadena Vacía.
Una cadena vacía es la única cadena de caracteres de tamaño cero. Y la
podemos denotar usualmente con letras λ o Є.

Concatenación de cadenas.
La concatenación de dos cadenas es unir las dos cadenas para formar una nueva.
El resultado de la concatenación es independiente del orden en que las
operaciones son ejecutadas. Matemáticamente esta propiedad es conocida como
asociatividad.

1.3 Lenguajes
Es un conjunto de cadenas, de todas las seleccionadas de un Σ*. donde Σ
determinado el alfabeto se denomina lenguaje. Si Σ es un alfabeto y L Σ*,
entonces L es un lenguaje de Σ. Un lenguaje de Σ no necesita incluir cadenas con
todos los símbolos de Σ. Pueden interpretarse como conjuntos de cadenas.

1.4 Tipos de lenguajes

Lenguaje maquina
Este lenguaje ordena a la máquina las operaciones fundamentales para su
funcionamiento. Consiste en la combinación de 0's y 1's para formar las ordenes
entendibles por el hardware de la máquina.
Este lenguaje es mucho más rápido que los lenguajes de alto nivel.
La desventaja es que son bastantes difíciles de manejar y usar, además de tener
códigos fuente enormes donde encontrar un fallo es casi imposible.

Lenguaje ensamblador
Es un derivado del lenguaje maquina y está formado por abreviaturas de letras y
números llamadas mnemotécnicos. Con la aparición de este lenguaje se crearon
los programas traductores para poder pasar los programas escritos en lenguaje
ensamblador a lenguaje máquina. Como ventaja con respecto al código máquina
es que los códigos fuentes eran más cortos y los programas creados ocupaban
menos memoria. Las desventajas de este lenguaje siguen siendo prácticamente
las mismas que las del lenguaje ensamblador, añadiendo la dificultad de tener que
aprender un nuevo lenguaje difícil de probar y mantener.

Lenguajes de alto nivel

Son aquellos que se encuentran más cercanos al lenguaje natural que al lenguaje
máquina.
Están dirigidos a solucionar problemas mediante el uso de Estructuras Dinámicas
de Datos.
Se tratan de lenguajes independientes de la arquitectura del ordenador. Por lo
que, en principio, un programa escrito en un lenguaje de alto nivel, lo puedes
migrar de una máquina a otra sin ningún tipo de problema.
Estos lenguajes permiten al programador olvidarse por completo del
funcionamiento interno de la maquina/s para la que están diseñando el programa.
Tan solo necesitan un traductor que entiendan el código fuente como las
características de la máquina.
Suelen usar tipos de datos para la programación y hay lenguajes de propósito
general y de propósito especifico.

Lenguaje declarativo
Es un tipo de lenguaje de programación más cercanos al razonamiento humano.
Los lenguajes declarativos no dicen cómo hacer una cosa, sino, más bien, qué
cosa hacer. No suele haber declaración de variables ni tipos.

1.5 Herramientas computacionales ligadas con

lenguajes
Traductor
Un traductor es un programa que tiene como entrada un texto escrito en un
lenguaje fuente y como salida produce un texto escrito en un lenguaje
objeto que preserva el significado de origen.
Ejemplos de traductores son los ensambladores y los compiladores.
Compilador.
El compilador es un programa informático que traduce un programa escrito en
lenguaje de programación y lo pasa a lenguaje de programación, podemos decir
que este programa nos permite traducir un código fuente de un programa en
lenguaje de nivel alto, y lo pasmos a otro nivel inferior.
Ensambladores
Analiza un programa y lo pasa a lenguaje máquina. Directa o indirecta la
traducción en que las instrucciones no son más que instrucciones que ejecuta la
computadora.
Interpretes.
Los intérpretes son los que realizan normalmente dos operaciones:
 Traducen el código fuente a un formato interno.
 Ejecuta o interpretan el programa traducido al formato interno.
Donde la primera pertenece al interprete el cual llama a veces al compilador, así
se genera el código interno, pero no es el lenguaje de máquina, ni lenguaje de
símbolos, ni mucho menos un lenguaje de nivel alto.
1.6 Estructura de un traductor
Un traductor divide su labor en dos etapas: una que analiza la entrada y genera
estructuras intermedias y otra que sintetiza la salida a partir de dichas estructuras.
Por tanto, el esquema de un traductor se representa de la siguiente manera:

Fase de análisis
Los dos objetivos de la etapa de análisis son:

 Controlar la corrección del programa fuente.

 Generar las estructuras necesarias para comenzar la etapa de síntesis

Fase de síntesis
La etapa de síntesis construye el programa objeto deseado a partir de las
estructuras generadas por la etapa de análisis.

1.7 Fases de un compilador

Análisis
El objetivo de esta etapa es obtener una representación de la entrada que nos
permita realizar la síntesis o la interpretación con comodidad.
Análisis léxico
En esta fase se analiza la entrada carácter a carácter y se divide en una serie de
unidades elementales: los componentes léxicos. Cada uno de estos componentes
se clasifica en una categoría y puede recibir uno o más atributos con información
relevante para otras fases. El criterio que se emplea para clasificar cada
componente es su pertenencia o no a un lenguaje. Esta fase además se encarga
de filtrar elementos tales como los blancos y los comentarios.
Análisis sintáctico
Partiendo de lo que ha recibido del analizador léxico, la tarea del analizador
sintáctico consiste en ir descubriendo las estructuras presentes en el código de
acuerdo con una gramática contextual. A partir de las estructuras que ha
encontrado, el analizador sintáctico construye un árbol sintáctico.
Análisis semántico
La última fase del análisis, el análisis semántico, toma como entrada el árbol
sintáctico y comprueba si, además de las restricciones sintácticas, se cumplen
otras restricciones impuestas por el lenguaje. Algunos ejemplos de estas
restricciones son la necesidad de declarar las variables antes de usarlas. Como
salida de esta fase, se obtiene una representación semántica.
Síntesis
Una vez analizado el programa de entrada, es necesario generar código, a ser
posible eficiente, para la máquina objetivo.
Generación de código intermedio
En esta etapa se traduce la entrada a una representación independiente de la
máquina, pero fácilmente traducible a lenguaje ensamblador. Esta representación
puede tomar diversas formas que pueden entenderse como visiones idealizadas
del lenguaje ensamblador de una máquina virtual.
Generación de código objeto
Una vez obtenido el código intermedio, es necesario generar el código objeto. Lo
habitual es que no se genere el código objeto directamente, sino que se genere
código en ensamblador y después se utilice un ensamblador. De cualquier forma,
esta fase es totalmente dependiente de la arquitectura concreta para la que se
esté desarrollando el compilador.
Optimización
Tanto a la hora de generar código intermedio como código objeto es habitual
encontrarse con que el resultado de la traducción es muy ineficiente. Esto es
debido a que la traducción se realiza de manera local, lo cual provoca la aparición
de código redundante, lo cual es necesario eliminar todas esas redundancias para
que mejore el funcionamiento.

La tabla de símbolos
A lo largo del proceso de análisis se va generando gran cantidad de información
que se puede considerar ligada a los objetos que se van descubriendo en el
programa: variables, constantes, funciones, etc. El acceso a esta información se
realiza mediante los nombres de estos objetos. Esto hace necesario tener alguna
manera de, a partir de un identificador, encontrar sus propiedades. La estructura
de datos que guarda esta información se denomina tabla de símbolos

Conclusión
El conocer que son los lenguajes formales y como funcionan es de suma
importancia, ya que estos son de gran utilidad para el área de sistemas, ya que un
desarrollador al encontrarse en su entorno de trabajo hará un gran uso de
herramientas que le ayuden a un correcto funcionamiento dentro de su área de
trabajo, una de estas herramientas puede ser un entorno de desarrollo integrado
(IDE) el cual es una herramienta que sirve para la creación de programas y/o
aplicaciones, la cual integra un compilador y un interprete generalmente, esto con
el fin de que un programador al momento de estar desarrollando una aplicación y
quiera saber si existe algún error en cuanto la sintaxis o semántica pueda
detectarlo fácilmente desde una de estas dos herramientas, estas herramientas a
día de hoy están tan desarrolladas que inclusive aparte de decirte que existe un
error te dicen cual es el error y en donde se encuentra, lo que es de gran utilidad
para los desarrolladores ya que hacen más eficiente la creación de más y mejor
software.

Bibliografía
Alfred V. Aho, M. S. (2008). Compiladores principios, técnicas y herramientas. México: Pearson
Education.

Rodríguez, L. A. (2010). Practique la Teoría de Autómatas Y Lenguajes Formales. Mexico: Elizcom.

Viñuela, P. I. (2001). Lenguajes, gramáticas y autómatas: un enfoque práctico. México: ADDISON-

WESLEY .