Este documento trata sobre compiladores y analizadores léxicos. Explica que un compilador es un programa que traduce un lenguaje de programación de alto nivel a otro de bajo nivel, como lenguaje de máquina. Describe las partes y tipos de compiladores, como compiladores optimizadores y cruzados. También cubre la historia de los compiladores desde los primeros en los años 1950 y explica las diferentes fases como análisis léxico, sintáctico y generación de código.

1. 1
COMPILADORES Y ANALIZADOR LEXICOS
LILIANA MARTINEZ REY
GIAN ANDREI GOMEZ CELIS
CORPORACION UNIVERSITARIA REMINGTON
FACULTA DE INGENIERIA
SISTEMAS VI
CUCUTA
2014

2. 2
TABLA DECONTENIDO
Introducción…………………………………………………………………………………………….…4
Justificación…………………………………………………………………..…………....................4
Objetivos generales y específicos………………………………………………….……….….5
1. UNCOMPILADOR…………………………………………………………………………………8
1.2. Imagen de un De Compilador…………………………………..…………………….….9
2. HISTORIA DE UN COMPILADOR.............................................................10
3.PARTES DE UN COMPILADOR………………………………………..........................12
3.1. Análisis....................................................................................................12
3.2. Síntesis…………………………………………………………………….............................12
4. TIPOS DE COMPILADORES……………………………….…………….…………………….13
4.1. Compiladores Cruzados………………………………………………………………..…….14
4.2. Compilador Optimizador……………………………………………………….…………14
4.3. Generalmente H ay Varios Aspectos Que Se Desean Optimizar………..14
4.4. Esta imagen es de un compilado optimizado……………………………………..15
4.5. Etapas De Compilación…..……….………………………………………………………..15
4.6. Compiladores De Una Sola Pasada…...............................................................16
4.7.compilador De Varias Pasadas…………………………………………………….……..17
4.8. Compilador De JIT………………………………………………………………………………17
4.9. Imagen De Compilador JIT.....................................................................18
5. PROCESO DE COMPILACIÓN………….………………………………………..…………18
6. FASES DE UN COMPILADOR……………………………………………………..…………..20
6.1. Fases De Análisis……………………………………………………………………….……….20
6.2. Fases De Sintáctico…………………………………………………………………….……...20
6.3. Análisis Semántico…………………………………………………………………….……….22

3. 6.4.Fases De Sintáis…………………………………………………………………..….…………..17
3
6.5. Generación De Código Intermedio………………………………………………………23
6.6. Optimización De Código…………………………………………………………..………..24
7. ANALIZADOR LEXICO……………………………………………………………................25
8. AUTOMATA FINITO…………………………………………………………………………..….26
8.1. Imagen De Autómata Finito……………………………………………………………….27
9. DIAGRAMA DE ESTADO……………………………………………………………………….28
9.1.Imagen De Diagrama De Estado………………………………………….................28
10. MAQUINA EN PILA………………………………………………………………………………29
11. BIOGRAFIAS………………………………………………………….30

4. 1. Introducción
En un mundo informatizado como en el que vivimos, en el que cada día que pasa
dependemos más y más de un sistema informático eficiente, el cual debe
estar preparado para brindarnos la más alta calidad de servicios y prestaciones.
Además de ser sencillo en su manejo y sobre todo confiable, siendo estas
características indispensables para el usuario final. Muchas pueden ser las
respuestas, algunos argumentara n que es el sistema operativo,
otros dirán que son las normas y estándares establecidos, otros dirán
irónicamente que es más sencillo de lo que se piensa, dirán que se hace aquí, se
arrastra y se lleva a donde se quiere. Todos ellos tienen razón, sin
embargo si indagamos más a fondo. Surgirán preguntas más directas
como por ejemplo "¿Cómo se logra tal velocidad, con tan buen manejo de
gráfico?", claro que a todas ellas se pu ede responder diciendo, que
todo se logra gracias al Hardware, y no estaríamos totalmente errados,
porque un buen Hardware con lleva unbuenresultado,aunabuenacalidaddeimpresiónen
casodevolcadoalpapel,una buena imagen si hablamos de gráficos, o un buen
tiempo de respuesta a ahora de realizar algún cálculo matemático, pero
siempre el Hardware será una parte, solo una parte .Es en este punto donde
surge el Software, los programas, o como el modernismo hoy endía,las
aplicaciones. Esdecirqueparaobtenerunbuenresultadono solo hace falta un buen
Hardware acorde a los requerimientos de la tarea que se quiere realizar, sino que
calidad, eficiencia, velocidad, y confiabilidad hoy en día son sinónimos de un
4

5. Buen trabajo en conjunto de la dupla Hardware y Software .Dejando de lado lo que
es el Hardware, y profundizando lo que representa su parte.
5

6. JUSTIFICACIÓN
Al aprobar las materias del área de matemática durante el ciclo básico de su carrera,
el
Estudiante adquiere el conocimiento general indispensable en cualquiera de las
carreras de
Ingeniería, sin embargo el modelaje matemático de un computador, también
conocido como la
Informática teórica o teoría de la computación aún es desconocido para él mismo.
Debido a la importancia de los compiladores durante el desenvolvimiento
académico y
Profesional de una persona que haga uso de las ciencias de la computación, es
importante
Que el alumno comprenda los principios fundamentales de cómo diseñar e
implementar los
Mismos, para esto se le dotará de las ideas básicas que le permitan al estudiante
Construir un compilador o intérprete, sin importar el lenguaje o máquina para la
cual se haga.
6

7. OBJETIVOS GENERALES
Comprender el problema que se enfrenta un compilador comprender los
algoritmos que se utilizan pare resolver cada una de las fases de un
Compilador
-OBJETIVOS ESPECIFICOS
Aplicar el concepto de un compilador como alternativa de solución de la
Problemática
Que los estudiantes sean capaces proyectos para su interés
7

8. 1. COMPILADOR
Un compilador es un programa informático que traduce un programa escrito en un lenguaje
de programación a otro lenguaje de programación, generando un programa equivalente que
la máquina será capaz de interpretar. Usualmente el segundo lenguaje es lenguaje de
maquina
Pero también puede ser un código intermedio (bytecode), o
simplemente texto. Este proceso de traducción se conoce
como compilación.
Un compilador es un programa que permite traducir el código fuente de un programa
en lenguaje de alto nivel, a otro lenguaje de nivel inferior (típicamente lenguaje de
máquina). De esta manera un programador puede diseñar un programa en un lenguaje
mucho más cercano a cómo piensa un ser humano, para luego compilarlo a un programa
más manejable por una computadora.
Como parte importante de este proceso de traducción, el
compilador informa a su usuario de la presencia de errores en
el programa fuente.
8

9. 1.2 Esta Imagen Es De Un Compilador
9

10. 2. HISTORIA DE UN COMPILADOR
En 1946 se desarrolló la primera computadora digital. En un principio, estas máquinas
Ejecutaban instrucciones consistentes en códigos numéricos que señalaban a los
Circuitos de la máquina los estados correspondientes a cada operación, lo que se
Denominó lenguaje máquina.
Pronto los primeros usuarios de estos ordenadores
Descubrieron la ventaja de escribir sus programas
Mediante claves más fáciles de recordar que esos códigos;
Al final, todas esas claves juntas se traducían manualmente
A lenguaje máquina. Estas claves constituyen los llamados
Lenguajes ensambladores.
Pese a todo, el lenguaje ensamblador seguía siendo el de una máquina, pero más fácil de
manejar. Los trabajos de investigación se orientaron hacia la creación de un lenguaje que
expresara las distintas acciones a realizar de una manera lo más sencilla posible para una
persona. El primer compilador fue escrito por Grace Hopper, en 1952 para el lenguaje de
programación A-0. En 1950 John Backus dirigió una investigación en IBM sobre un
lenguaje algebraico. En 1954 se empezó a desarrollar un lenguaje que permitía escribir
fórmulas matemáticas de manera traducible por un ordenador; le llamaron FORTRAN
(formulae translator). Fue el primer lenguaje de alto nivel y se introdujo en 1957 para el
uso de la computadora IBM modelo 704.
Surgió así por primera vez el concepto de un traductor como
un programa que traducía un lenguaje a otro lenguaje.
10

11. En el caso particular de que el lenguaje a traducir es un
lenguaje de alto nivel y el lenguaje traducido de bajo nivel, se
emplea el término compilador.
La tarea de realizar un compilador no fue fácil. El primer compilador de FORTRAN tardó
18 años-persona en realizarse y era muy sencillo. Este desarrollo de FORTRAN estaba
muy influenciado por la máquina objeto en la que iba a ser implementado. Como un
ejemplo de ello tenemos el hecho de que los espacios en blanco fuesen ignorados, debido a
que el periférico que se utilizaba como entrada de programas (una lectora de tarjetas
perforadas) no contaba correctamente los espacios en blanco.
El primer compilador auto contenido, es decir, capaz de
compilar su propio código fuente fue el creado para Lisp por
Hart y Lavín en el MIT en 1962. Desde 1970 se ha
convertido en una práctica común escribir el compilador en el
mismo lenguaje que este compila, aunque Pascal y C han sido
alternativas muy usadas.
Crear un compilador autocontenido genera un problema llamado bootstrapping, es decir el
primer compilador creado para un lenguaje tiene que o bien ser compilado por un
compilador escrito en otro lenguaje o bien compilado al ejecutar el compilador e
11

12. 3. PARTES DE UN COMPILADOR
La construcción de un compilador involucra la división del proceso en una serie de fases
que variará con su complejidad. Generalmente estas fases se agrupan en dos tareas: el
análisis del programa fuente y la síntesis del programa objeto.
3.1. Análisis: Se trata de la comprobación de la corrección del programa fuente, e incluye
las fases correspondientes al Análisis léxico (que consiste en la descomposición del
programa fuente en componentes léxicos), Análisis sintáctico (agrupación de los
componentes léxicos en frases gramaticales ) y Análisis semántico (comprobación de la
validez semántica de las sentencias aceptadas en la fase de Análisis Sintáctico).
3.2. Síntesis: Su objetivo es la generación de la salida expresada en el lenguaje objeto y
suele estar formado por una o varias combinaciones de fases de Generación de
Código (normalmente se trata de código intermedio o de código objeto) y de
Optimización de Código (en las que se busca obtener un código lo más eficiente
posible).
Alternativamente, las fases descritas para las tareas de análisis y síntesis se pueden agrupar
en Front-end y Back-end:
 Front-end: es la parte que analiza el código fuente, comprueba su validez, genera
el árbol de derivación y rellena los valores de la tabla de símbolos. Esta parte suele ser
independiente de la plataforma o sistema para el cual se vaya a compilar, y está
compuesta por las fases comprendidas entre el Análisis Léxico y la Generación
12

13.  Back-end: es la parte que genera el código máquina, específico de una plataforma, a
partir de los resultados de la fase de análisis, realizada por el Front End.
Esta división permite que el mismo Back End se utilice para generar el código máquina de
varios lenguajes de programación distintos y que el mismo Front End que sirve para
analizar el código fuente de un lenguaje de programación concreto sirva para
generar código máquina en varias plataformas distintas. Suele incluir la generación y
optimización del código dependiente de la máquina.
El código que genera el Back End normalmente no se puede ejecutar directamente, sino
que necesita ser enlazado por un programa enlazador (linker)
4. TIPOS DE COMPILADORES
Esta taxonomía de los tipos de compiladores no es excluyente, por lo que puede haber
compiladores que se adscriban a varias categorías:
13

14. 4.1. Compiladores Cruzados
Un compilador capaz de crear código ejecutable para otra plataforma distinta a aquélla en
la que él se ejecuta. Esta herramienta es útil cuando quiere compilarse código para una
plataforma a la que no se tiene acceso, o cuando es incómodo o imposible compilar en
dicha plataforma (como en el caso de los sistemas embebidos).
Un ejemplo de un compilador con estas posibilidades es el NASM, que puede ensamblar,
entre otros formatos ELF (para sistemas UNIX) y COM (para DOS).
4.2. Compilador Optimizador
En ciencias de la computación, un compilador optimizador es un compilador que trata de
minimizar ciertos atributos de un programa informático con el fin de aumentar la eficiencia
y rendimiento. Las optimizaciones del compilador se aplican generalmente mediante una
secuencia de transformaciones de optimización, algoritmos que transforman un programa
para producir otro con una salida semánticamente equivalente pero optimizado.
4.3. Generalmente Hay Varios Aspectos Que Se Desean Optimizar:
Optimización temporal: Reducir el tiempo de ejecución del programa.
Optimización espacial: Reducir la cantidad de espacio en memoria que ocupa el
programa en ejecución.
Reducir el tamaño del programa.
14

15. Minimizar la potencia consumida por un programa (debido a las computadoras
portátiles).
4.4. Esta Imagen Es De Un Compilador Optimizado
4.5. Etapas De Compilación
La optimización se realiza después de la generación de código de todo el programa o de un
elemento ejecutable del programa (función, procedimiento, etc.), por ende es dependiente
del contexto.4
La condición que ha de cumplir es que el código optimizado se ha de
comportar igual que el código de partida, excepto por ser más rápido o ocupar menos
espacio.
15

16. Se ha demostrado que algunos problemas de optimización de código son NP-completo, o
incluso indecidibles. En la práctica, factores como la voluntad del programador que debe
esperar a que el compilador complete sus tareas, imponen límites superiores en las
optimizaciones que las que una simple implementación del compilador puede proporcionar
(la optimización es un proceso muy intensivo que generalmente necesita mucho
procesamiento y memoria para llevarse a cabo). En el pasado, las limitaciones de memoria
de las computadoras también eran un factor importante en la limitación de las
optimizaciones que se podían realizar. Debido a todos estos factores, la optimización rara
vez produce una salida de forma óptima (valga la redundancia), y el hecho de que una
optimización pueda impedir el rendimiento en algunos casos, hace que, sean métodos
heurísticos para mejorar el uso de los recursos en los programas típicos.
La optimización es el campo donde se hace más investigación
en los compiladores hoy en día.
Las tareas del front-end (exploración, análisis sintáctico, análisis léxico, análisis
semántico) son bien conocidas y, sin optimizar, la generación de código es relativamente
sencilla. La optimización, por otra parte, aún es un campo que no se ha terminado de
desarrollar.
4.6. Compiladores De Una Sola Pasada: generan el código máquina a partir de una
única lectura del código fuente.
16

17. 4.7. Compiladores De Varias Pasadas.
Necesitan leer el código fuente varias veces antes de poder producir el código
máquina.
4.8. Compiladores JIT
En las primeras épocas de la informática, el software de los compiladores era considerado
como uno de los más complejos existentes.
Los primeros compiladores se realizaron programándolos directamente en lenguaje
máquina o en ensamblador. Una vez que se dispone de un compilador, se pueden escribir
nuevas versiones del compilador (u otros compiladores distintos) en el lenguaje que
compila ese compilador.
17

18. Actualmente existen herramientas que facilitan la tarea de escribir compiladores
o intérpretes informáticos. Estas herramientas permiten generar el esqueleto del analizador
sintáctico a partir de una definición formal del lenguaje de partida, especificada
normalmente mediante una gramática formal y barata, dejando únicamente al programador
del compilador la tarea de programar las acciones semánticas asociadas.
4.9. Imagen De Compilador JIT
5. PROCESO DE COMPILACIÓN
Es el proceso por el cual se traducen las instrucciones escritas en un determinado lenguaje
de programación a lenguaje máquina. Además de un traductor, se pueden necesitar otros
programas para crear un programa objeto ejecutable. Un programa fuente se puede dividir
en módulos almacenados en archivos distintos. La tarea de reunir el programa fuente a
menudo se confía a un programa distinto, llamado preprocesador. 18

19. El preprocesador también puede expandir abreviaturas, llamadas a macros, a
proposiciones del lenguaje fuente.
Normalmente la creación de un programa ejecutable (un típico.exe para Microsoft
Windows o DOS) conlleva dos pasos. El primer paso se llama compilación (propiamente
dicho) y traduce el código fuente escrito en un lenguaje de programación almacenado en
un archivo a código en bajo nivel (normalmente en código objeto, no directamente a
lenguaje máquina). El segundo paso se llama enlazado en el cual se enlaza el código de
bajo nivel generado de todos los ficheros y subprogramas que se han mandado compilar y
se añade el código de las funciones que hay en las bibliotecas del compilador para que el
ejecutable pueda comunicarse directamente con el sistema operativo, traduciendo así
finalmente el código objeto a código máquina, y generando un módulo ejecutable.
Estos dos pasos se pueden hacer por separado, almacenando el resultado de la fase de
compilación en archivos objetos (un típico.obj para Microsoft Windows, DOS o
para Unix); para enlazarlos en fases posteriores, o crear directamente el ejecutable; con lo
que la fase de compilación se almacena sólo temporalmente. Un programa podría tener
partes escritas en varios lenguajes (por ejemplo C, C++ y Asm), que se podrían compilar
de forma independiente y luego enlazar juntas para formar un único módulo ejecutable.
19

20. 6. FASES DE UN COMPILADOR
6.1. Fase De Análisis
El análisis léxico constituye la primera fase, aquí se lee el programa fuente de izquierda a
derecha y se agrupa en componentes léxicos (tokens), que son secuencias de caracteres que
tienen un significado. Además, todos los espacios en blanco, líneas en blanco, comentarios
y demás información innecesaria se elimina del programa fuente. También se comprueba
que los símbolos del lenguaje (palabras clave, operadores, etc.) se han escrito
correctamente.
Como la tarea que realiza el analizador léxico es un caso especial de coincidencia de
patrones, se necesitan los métodos de especificación y reconocimiento de patrones, se usan
principalmente los autómatas finitos que acepten expresiones regulares. Sin embargo, un
analizador léxico también es la parte del traductor que maneja la entrada del código fuente,
y puesto que esta entrada a menudo involucra un importante gasto de tiempo, el analizador
léxico debe funcionar de manera tan eficiente como sea posible
6.2. Análisis Sintáctico
En esta fase los caracteres o componentes léxicos se agrupan jerárquicamente en frases
gramaticales que el compilador utiliza para sintetizar la salida. Se comprueba si lo
20

21. Obtenido de la fase anterior es sintácticamente correcto (obedece a la gramática del
lenguaje). Por lo general, las frases gramaticales del programa fuente se representan
mediante un árbol de análisis sintáctico.
La estructura jerárquica de un programa normalmente se expresa utilizando
reglas recursivas. Por ejemplo, se pueden dar las siguientes reglas como parte de la
definición de expresiones:
1. Cualquier identificador es una expresión.
2. Cualquier número es una expresión.
3. Si expresión1 y expresión2 son expresiones, entonces también lo son:
 expresión1 + expresión2
 expresión1 * expresión2
 ( expresión1 )
Las reglas 1 y 2 son reglas básicas (no recursivas), en tanto que la regla 3 define
expresiones en función de operadores aplicados a otras expresiones.
La división entre análisis léxico y análisis sintáctico es algo arbitraria. Un factor para
determinar la división es si una construcción del lenguaje fuente es inherentemente
recursiva o no. Las construcciones léxicas no requieren recursión, mientras que las
construcciones sintácticas suelen requerirla. No se requiere recursión para reconocer los
identificadores, que suelen ser cadenas de letras y dígitos que comienzan con una letra.
Normalmente, se reconocen los identificadores por el simple examen del flujo de entrada,
esperando hasta encontrar un carácter que no sea ni letra ni dígito, y agrupando después
todas las letras y dígitos encontrados hasta ese punto en un componente léxico
llamado identificador. Por otra parte, esta clase de análisis no es suficientemente poderoso
para analizar expresiones o proposiciones. 21

22. Por ejemplo, no podemos emparejar de manera apropiada los paréntesis de las
expresiones, o las palabras begin y ende en proposiciones sin imponer alguna clase de
estructura jerárquica o de anidamiento a la entrada.
6.3. Análisis Semántico
La fase de análisis semántico revisa el programa fuente para tratar de encontrar errores
semánticos y reúne la información sobre los tipos para la fase posterior de generación de
código. En ella se utiliza la estructura jerárquica determinada por la fase de análisis
sintáctico para identificar los operadores y operandos de expresiones y proposiciones.
Un componente importante del análisis semántico es la verificación de tipos. Aquí, el
compilador verifica si cada operador tiene operandos permitidos por la especificación del
lenguaje fuente. Por ejemplo, las definiciones de muchos lenguajes de programación
requieren que el compilador indique un error cada vez que se use un número real como
índice de una matriz. Sin embargo, la especificación del lenguaje puede imponer
restricciones a los operan dos, por ejemplo, cuando un operador aritmético binario se
Aplica a un número entero y a un número real. Revisa que los arreglos tengan definido el
tamaño correcto.
22

23. 6.4. Fase de Síntesis
Consiste en generar el código objeto equivalente al programa fuente. Sólo se genera código
objeto cuando el programa fuente está libre de errores de análisis, lo cual no quiere decir
que el programa se ejecute correctamente, ya que un programa puede tener errores de
concepto o expresiones mal calculadas. Por lo general el código objeto es código de
máquina re localizable o código ensamblador. Las posiciones de memoria se seleccionan
para cada una de las variables usadas por el programa. Después, cada una de las
instrucciones intermedias se traduce a una secuencia de instrucciones de máquina que
ejecuta la misma tarea. Un aspecto decisivo es la asignación de variables a registros.
6.5. Generación De Código Intermedio
Después de los análisis sintáctico y semántico, algunos compiladores generan una
representación intermedia explícita del programa fuente. Se puede considerar esta
representación intermedia como un programa para una máquina abstracta. Esta
representación intermedia debe tener dos propiedades importantes; debe ser fácil de
producir y fácil de traducir al programa objeto.
La representación intermedia puede tener diversas formas. Existe una forma intermedia
llamada «código de tres direcciones» que es como el lenguaje ensamblador de una
máquina en la que cada posición de memoria puede actuar como un registro. El código de
tres direcciones consiste en una secuencia de instrucciones, cada una de las cuales tiene
como máximo tres operan dos. Esta representación intermedia tiene varias propiedades:
23

24. Primera.- Cada instrucción de tres direcciones tiene a lo sumo un operador, además de
la asignación, por tanto, cuando se generan estas instrucciones, el traductor tiene que
decidir el orden en que deben efectuarse las operaciones.
 Segunda.- El traductor debe generar un nombre temporal para guardar los valores
calculados por cada instrucción.
 Tercera.- Algunas instrucciones de «tres direcciones» tienen menos de tres operan dos,
por ejemplo, la asignación
6.6. Optimización De Código
La fase de optimización de código consiste en mejorar el código intermedio, de modo que
resulte un código máquina más rápido de ejecutar. Esta fase de la etapa de síntesis es
posible sobre todo si el traductor es un compilador (difícilmente un intérprete puede
optimizar el código objeto). Hay mucha variación en la cantidad de optimización de código
que ejecutan los distintos compiladores. En los que hacen mucha optimización, llamados
«compiladores optimizadores», una parte significativa del tiempo del compilador se ocupa
en esta fase. Sin embargo, hay optimizaciones sencillas que mejoran sensiblemente el
tiempo de ejecución del programa objeto sin retardar demasiado la compilación
24

25. 7. ANALIZADOR LEXICO
El analizador léxico lee los caracteres del programa fuente, y verifica
Correspondan a una secuencia lógica (identificador, palabra reservada etc.). Esta
secuencia de caracteres recibe el nombre componente léxico o lexema. En este
caso el analizador léxico verifica si el identificador id1 (nombre interno para
“suma") encontrado se halla en la tabla de símbolos, si no está produce un
error porque todavía no fue declarado, si la preposición hubiese sido la declaración del
identificador "suma" en lenguajes C, C++ (int suma;) el analizador
léxico agregaría un identificador en la tabla de símbolos, y así sucesivamente con todos
los componentes léxicos que aparezcan, los componentes léxicos resultantes de la expresión
son:Identificador:
Suma.
Elsímbolodeasignación:
=
Identificador:
var1
Operador:
+
Identificador:
var2
Operador:
+
25

26. Queenelanálisisléxicoyconlatabladesímboloses:
id1= id2+ id3 * 10Análisis Sintáctico
E l a n a l i z a d o r s i n t á c t i c o i m p o n e u n a e s t r u c t u r a j e r á r q u i c a a l a
c a d e n a d e componentes léxicos, generada por el analizador léxico, que es
representada en formadeun árbolsintáctico.
8. AUTÓMATA FINITO
(Máquina de estado finito). Es un modelo computacional que realiza cómputos en forma
automática sobre una entrada para producir una salida.
Este modelo está conformado por un alfabeto, un conjunto de estados y un conjunto de
transiciones entre dichos estados. Su funcionamiento se basa en una función de transición,
que recibe a partir de un estado inicial una cadena de caracteres pertenecientes al alfabeto
(la entrada), y que va leyendo dicha cadena a medida que el autómata se desplaza de un
estado a otro, para finalmente detenerse en un estado final o de aceptación, que representa
la salida.
La finalidad de los autómatas finitos es la de reconocer lenguajes regulares, que
corresponden a los lenguajes formales más simples según la Jerarquía de Chomsky.
26

27. 8.1.Esta Imagen es De Un Autómata Finito
27
Autómata finito

28. 9. D IAGRAMA DE ESTADO
Este muestra la secuencia de estados por los que pasa bien un caso de uso, un objeto a lo
largo de su vida, o bien todo el sistema. Es una forma de representación gráfica más
intuitiva de los autómatas finitos basadas en dígrafos con arcos acotados llamados
transiciones en los cuales se ponen los símbolos de tránsito entre un vértice (estado) y otro
y se identifican los estados de partida y los de aceptación del resto. Los diagramas de
estados finitos son también representaciones más cómodas para su elaboración, legibilidad
y comprensión de distintos tipos de abstracciones computacionales de reconocimiento
como los autómatas de pila y las máquinas de Turing
9.1. Esta Imagen Es De Un Diagrama De Estado
Concept
o
Muestra la secuencia de estados por los que pasa bien un caso de uso, un
objeto a lo largo de su vida, o bien todo el sistema
28

29. 10. MAQUINA EN PILA
Una máquina de pila es un modelo computacional en el cual la memoria de la computadora
toma la forma de una o más pilas. El término también se refiere a un computador real
implementando o simulando una máquina de pila idealizada.
Adicionalmente, una máquina de pila también puede referirse a una máquina verdadera o
simulada con un conjunto de instrucciones de "0 operandos". En tal máquina, la mayoría
de las instrucciones implícitamente operan en valores en el tope de la pila y reemplazan
esos valores por el resultado. Típicamente tales máquinas también tienen una instrucción
"load" y una instrucción "store" que leen y escriben a posiciones arbitrarias de la RAM.
(Como el resto de las instrucciones, las instrucciones "load" y "store" no necesitan ningún
operando en una máquina de pila típica - ellas siempre toman la dirección de la RAM que
se quiere leer o escribir desde el tope de la pila).
La ventaja de las máquinas de pila ("conjunto de instrucciones de 0 operan dos") sobre las
máquinas de acumulador ("conjunto de instrucciones de 1 operando") y las máquinas de
registro ("conjunto de instrucciones de 2 operan dos" o un "conjunto de instrucciones de 3
operan dos") es que los programas escritos para un conjunto de instrucciones de "0 operan
dos" generalmente tienen una densidad de código más alta que los programas equivalentes
escritos para otros conjuntos de instrucciones.
29

30. BIOGRAFIAS
www.google.com.co
www.slideshare.net/jonathangrief/compiladores
30