El resumen describe la historia de los compiladores, sus principales componentes y el proceso de traducción. Específicamente, habla sobre la evolución de los lenguajes de programación desde el lenguaje máquina hasta lenguajes como FORTRAN, y explica que un compilador traduce un programa escrito en un lenguaje fuente a un programa equivalente en un lenguaje objetivo. Además, describe las distintas fases del proceso de traducción de un compilador como el analizador léxico, analizador sintáctico, analizador

1. INSTITUTO POLITÉCNICO NACIONAL
ESCUELA SUPERIOR DE INGENIERÍA MECÁNICA Y ELÉCTRICA
INGENIERÍA EN COMPUTACIÓN
COMPILADORES
RESUMEN DEL CAPÍTULO I
ALUMNO(S):
LECHUGA ORTEGA JESÚS ALEJANDRO
GRUPO: 5CM24 TURNO: MATUTINO
FECHA DE ENTREGA: 22/08/2018

2. 2
Índice
Índice ....................................................................................................................................... 2
Introducción ............................................................................................................................. 3
Justificación.............................................................................................................................. 3
Objetivos de aprendizaje ........................................................................................................... 3
Desarrollo................................................................................................................................. 4
Historia de los compiladores...................................................................................................... 4
Programas relacionados con los compiladores............................................................................ 6
Proceso de Traducción............................................................................................................... 8
Estructuras de Datos Principales en un Compilador....................................................................12
Referentes a la Estructura del Compilador.................................................................................13
Arranque Automático y Portabilidad..........................................................................................14
Conclusiones............................................................................................................................15
Glosario...................................................................................................................................16
Bibliografía...............................................................................................................................18

3. 3
Introducción
En el siguiente texto se hará un resumen del capitulo I del libro
“Construcción de compiladores, principios y prácticas” del autor:
Kenneth C. Louden.
Justificación
En este texto se realiza un resumen del libro anteriormente mencionado, para
hablar sobre la historia de estos, su proceso, sus referentes, la estructura,
además de su arranque y su portabilidad.
Objetivos de aprendizaje
 Comprender la historia de los compiladores
 Los programas relacionados a los compiladores
 El proceso de traducción
 Las principales estructuras de datos de un compilador
 El arranque y la portabilidad
 El lenguaje y compilador muestra

4. 4
Desarrollo
Los compiladores son programas de computadora que traducen un lenguaje
a otro. Un compilador toma como entrada su programa escrito en su lenguaje
fuente y produce un programa equivalente escrito en su lenguaje objetivo.
Un compilador es un programa muy complejo con un número de líneas de
código que puede variar de 10,000 a 1,000,000. Escribir un programa de esta
naturaleza, o incluso comprenderlo no es una tarea fácil, y la mayoría de los
científicos y profesionales nunca se terminará de escribir un compilador
completo.
Historia de los compiladores
Con el advenimiento de la computadora con el programa almacenado,
iniciado por John von Neumann a finales de la década de 1940, se hizo
necesario escribir secuencias de códigos o programas, que darían como
resultado que estas computadoras realizaran los cálculos numéricos que
representaban las operaciones reales que iban a efectuarse.
C7 06 0000 0002
La escritura de tales códigos es muy tediosa y consume mucho tiempo por lo
que esta forma de codificación fue reemplazada por el lenguaje
ensamblador, en la cual las instrucciones y localidades son formas más
simbólicas dadas.
MOV X, 2
El lenguaje ensamblador mejoro enormemente la velocidad y exactitud con
la que podían escribirse los programas y en la actualidad se encuentra en
uso, en especial cuando se necesita una gran velocidad o brevedad en el
código.
El desarrollo del lenguaje FORTRAN y su compilador, llevado acabo por un
equipo de IBM dirigido por John Backus entre 1954 y 1957 demostró que
las operaciones de un programa podrían ser más fáciles para que se
parecieran a la notación matemática o lenguaje natural.
Al mismo tiempo en que el primer compilador se estaba desarrollando, Noam
Chomsky comenzó a estudiar la estructura del lenguaje natural.
Los estudios de Chomsky condujeron a la clasificación de los lenguajes
acuerdo con la complejidad de sus gramáticas (las reglas que especifican
su estructura) y la potencia de los algoritmos necesarios para reconocerlas.

5. 5
Los autómatas finitos y las expresiones regulares, que corresponden a las
gramáticas de tipo 3 de Chomsky, se encuentran estrechamente
relacionados con las gramáticas libres de contexto.
A medida que el problema del análisis sintáctico se comprendía bien se
dedicó mucho trabajo a desarrollar programas que automatizaran esta parte
del desarrollo de compiladores.
A finales de los 70 y principios de los 80 diversos proyectos se enfocaron en
automatizar la generación de otras partes de un compilador, incluyendo la
generación de código
Los avances mas recientes en el diseño de los compiladores aun incluido lo
siguiente:
 Algoritmos más complicados
 Lenguajes más sofisticados
Gracias a esto se desarrollaron los IDE (Interactive Development
Environment).

6. 6
Programas relacionadoscon los compiladores
 Interpretes
o Un interprete es un traductor de lenguaje, igual que un compilador,
pero difiere de este en que ejecuta el programa fuente
inmediatamente, en vez de generar un código objeto, que se ejecuta
después de que se completa la traducción
 Ensambladores
o Un ensamblador es un traductor para el lenguaje ensamblador de una
computadora en particular.
 Ligadores
o Tanto los compiladores como los ensambladores a menudo dependen
de un programa conocido como ligador, el cual recopila código que se
compila o se ensambla por separado en diferentes archivos objeto, a
un archivo que es directamente ejecutable.
 Cargadores
o Con frecuencia un compilador, ensamblador o ligador producirá un
código que todavía no esta completamente organizado y listo para
ejecutarse, pero cuyas principales referencias de memoria se hacen
relativas a una localidad de arranque indeterminada que puede estar
en cualquier sitio de la memoria.
 Preprocesadores
o Un preprocesador es un programa separado que es invocado por el
compilador antes de que comencé la traducción real, elimina los
comentarios además de eliminar los comentarios, incluir otros
archivos y ejecutar situaciones de macro.
 Editores
o Los compiladores por lo regular aceptan programas fuente escritos
utilizando cualquier editor que pueda producir un archivo estándar, tal
como un archivo ASCII; Un editor, mientras que aun puede produce
archivos estándar, pueden ser orientado hacia el formato o estructura
del lenguaje de programación es cuestión.
 Depuradores
o Un depurador es un programa que puede utilizarse para determinar
errores de ejecución en un programa compilado.
 Perfiladores
o Un perfilador es un programa que recolecta estadísticas sobre el
comportamiento de un programa objeto durante la ejecución.

7. 7
 Administradores de proyecto
o Un administrador de proyecto puede escribirse en una gorma
independiente del lenguaje, pero cuando se integra junto con un
compilador puede mater información acerca del compilador especifico
y de las operaciones de ligado necesarias para construir un programa
ejecutable completo.

8. 8
Proceso de Traducción
Un compilador se compone de internamente de varias etapas o fases, que
realizan distintas operaciones lógicas.

9. 9
 Analizador léxico o rastreador (SCANNER)
o Esta fase del compilador efectúa la lectura real del programa
fuente, el cual generalmente esta en la forma de un flujo de
caracteres. El rastreador realiza lo que conocemos como
análisis léxico: recolecta secuencias de caracteres en
unidades significativas determinadas tokens.
 Analizador sintáctico (PASER)
o El analizador sintáctico recibe el código fuente en la forme de
tokens proveniente del analizador léxico y realiza el análisis
sintáctico que determina la estructura del programa. El análisis
sintáctico determina los elementos estructurales del programa
y sus relaciones. Los resultados del análisis sintáctico por lo
regular se representan como un árbol de análisis gramatical
o un árbol sintáctico.
Árbol de análisis gramatical

10. 10
Árbol sintáctico
 Analizador semántico
o La semántica de un programa es su “significado”, en oposición
a su sintaxis o estructura. Se hace referencia a tales
características como semántica estática, y el análisis de tal
semántica es la tarea del analizador semántico.
 Optimizador de código fuente
o El punto mas anticipado en que la mayoría de las etapas de
optimización se pueden realizar es precisamente después del
análisis semántico, y puede haber posibilidades para el
mejoramiento del código que dependerá solo del código fuente.
 Generador de código
o El generador de código toma el código intermedio y genera el
código para la quina objetivo. Es en esta fase de la compilación
en las que las propiedadesde la maquina objetivo se convierten
en el factor principal.

11. 11
 Optimizador de código objetivo
o En esta fase el compilador intenta mejorar el código objetivo
generado por el generador de código. Dichas mejoras incluyen
la selección de modos de direccionamiento para mejorar el
rendimiento, reemplazando las instrucciones lentas por otras
rápidas, y eliminando las operaciones redundantes o
innecesarias.

12. 12
Estructuras de Datos Principales en un Compilador
La interacción entre los algoritmos utilizados por las fases de un compilador
y las estructuras de datos que soportan estas faces, es naturalmente muy
fuerte. DE manera ideal, un compilador debería poder compilar un programa
en un tiempo proporcional al tamaño del programa es de decir O(n) tiempo
donde n es una medida del tamaño del programa (por lo general el número
de caracteres).
 Tokens
o Cuando un rastreador o analizador léxico reúne los caracteres en un
token, generalmente representa el token de manera simbólica, es
decir, como un valor de un tipo de datos enumerado que representa el
conjunto de tokens del lenguaje fuente.
 Árbol sintáctico
o Si el analizador sintáctico genera un árbol sintáctico, por lo regular se
construye como una estructura estándar basada en un apuntador que
se asigna de manera dinámica a medida que se efectúa el análisis
sintáctico.
 Tabla de símbolos
o Esta estructura de datos mantiene la información con los
identificadores: funciones, variables, constantes y tipos de datos. La
tabla de símbolos interactúa con casi todas las fases del compilador.
 Tabla de literales
o La búsqueda y la inserción rápida son esenciales también para la tabla
de literales, la cual almacena constantes y cadenas utilizadas en el
programa.
 Código intermedio
o Este código puede conservarse como un arreglo de cadenas de texto,
un archivo de texto temporal o bien una lista de estructuras ligadas.
 Archivos temporales
o Estos archivos solo mantienen la información suficiente de las partes
anteriores del programa fuente que permita proceder a la traducción

13. 13
Referentes a la Estructura delCompilador
 Análisis y Síntesis
o En esta perspectiva las operaciones del compilador que analizan el
programa fuente para calcular sus propiedades se clasifican como la
parte de análisis del compilador, mientras que las operaciones
involucradas en la producción del código traducido se conocen como
la parte de síntesis del compilador.
 Etapa inicial y Etapa Final
o Etapa inicial
 Aquellas funciones que dependen solo del lenguaje inicial
o Etapa Final
 Aquellas operaciones que dependen únicamente del lenguaje
objetivo
 Pasadas
o Un compilador a menudo encuentra conveniente procesar todo el
programa fuente varias veces antes de generar el código. Las pasadas
pueden corresponder o no a las fases, a menudo una pasada
consistirá de varias etapas. En realidad, dependiendo del lenguaje, un
compilador puede ser de una pasada, en el que todas las fases se
representan durante un paso único.
 Manejo de errores
o Una de las funciones mas importantes de un compilador es su
resultado a los errores en un programa fuente. Los errores pueden ser
detectados durante casi cualquier fase de la compilación. Los errores
deben ser notificados por un compilador, y es importante que el
compilador sea capaz de generar mensajes de error significativos y
reanudar la compilación después de cada error.

14. 14
ArranqueAutomático y Portabilidad
Para que el compilador se ejecute inmediatamente, este lenguaje de
implementación (lenguaje anfitrión) tendría que ser lenguaje máquina. Si el
compilador existente ya se ejecuta en la maquina objetivo, entonces
solamente necesitamos compilar el nuevo compilador utilizando el
compilador existente para obtener un programa ejecutable.
Si el compilador existente para el lenguaje B se ejecuta en una maquina
diferente de la maquina objetivo, entonces la situación es mas complicada.
Lo que ocurre aquí es un compilador cruzado, es decir, un compilador que
genera código objetivo para una maquina diferente de aquella en la que
puede ejecutarse.

15. 15
Conclusiones
Con la ayuda de este pequeño resumen se supo un poco de la importancia a
través de la historia de los compiladores, el motivo del por qué fueron
creados, para dar mayor facilidad a la hora de codificar algún programa
además de grandes ayudas y reducción de tiempo e incluso reducción de
errores; se dio paso a las palabras técnicas que se emplearan a lo largo el
curso, además de temas realmente importantes como las etapas de un
compilador, que la meta de este curso es hacer nuestro propio compilador en
las fases:
1. Analizador léxico
2. Analizador sintáctico
3. Analizador semántico
4. Optimizador de código fuente
5. Generador de código
6. Optimizador de código objetivo

16. 16
Glosario
 Lenguaje fuente:
El código fuente de un programa informático (o software) es un conjunto de
líneas de texto con los pasos que debe seguir la computadora para ejecutar
dicho programa.
 Lenguaje objetivo
En programación, se llama lenguaje objeto al código que resulta de la
compilación del código fuente.
 Lenguaje ensamblador:
El lenguaje ensamblador consiste en un conjunto de mnemónicos que
representan instrucciones básicas para los computadores,
microprocesadores, microcontroladores y otros circuitos integrados
programables.
 Gramática:
La gramática es el estudio de las reglas y principios que gobiernan el uso de
las lenguas y la organización de las palabras dentro de unas oraciones y otro
tipo de constituyentes sintácticos.
 Autómatas finitos:
Un autómata finito (AF) o máquina de estado finito es un modelo
computacional que realiza cómputos en forma automática sobre una entrada
para producir una salida.
 Expresiones regulares:
Es una secuencia de caracteres que forma un patrón de búsqueda,
principalmente utilizada para la búsqueda de patrones de cadenas de
caracteres u operaciones de sustituciones.
 IDE (Interactive Development Environment):
Aplicación informática que proporciona servicios integrales para facilitarle al
desarrollador o programador el desarrollo de software.
 Macro:
Son un conjunto de comandos que se invocan con una palabra clave,
opcionalmente seguidas de parámetros que se utilizan como código literal.
Los Macros son manejados por el compilador y no por el ejecutable
compilado.

17. 17
 Análisis léxico:
Un analizador léxico o analizador lexicográfico (en inglés scanner) es la
primera fase de un compilador consistente en un programa que recibe como
entrada el código fuente de otro programa (secuencia de caracteres) y
produce una salida compuesta de tokens (componentes léxicos) o símbolos.
 Tokens:
Un token o también llamado componente léxico es una cadena de caracteres
que tiene un significado coherente en cierto lenguaje de programación.
 Árbol sintáctico:
Es una representación de árbol de la estructura sintáctica abstracta
(simplificada) del código fuente escrito en cierto lenguaje de programación.
 Semántica estática:
La semántica estática define las restricciones sobre la estructura de los textos
válidos que resulta imposible o muy difícil expresar mediante formalismos
sintácticos estándar.
 Lenguaje anfitrión:
Las instrucciones de manejo que define van dentro de un lenguaje de alto
nivel cualquiera
 Compilador cruzado:
Es un compilador capaz de crear código ejecutable para otra plataforma
distinta a aquélla en la que el compilador se ejecuta.

18. 18
Bibliografía
Construcción de compiladores, principios y prácticas”, Kenneth C.
Louden.
Compiladores Teoría e implementación Jacinto Ruiz
Compiladores e intérpretes: teoría y práctica, Alfonso Ortega de la
Puente