Portafolio Lenguajes y Autómatas Unidad 1

Luis Adrian Parra Avellaneda Lenguajes Autómatas I
Instituto Tecnológico de Tepic
Ingeniería en Sistemas Computacionales
UNIDAD 1
PORTAFOLIO
Alumno: Luis Adrian Parra Avellaneda
NC: 10400978
Materia: Lenguajes Autómatas - 1

1
Introducción general del portafolio de la unidad 1
La materia de lenguajes autómatas es de las más importantes dentro de la carrera de un
ingeniero en sistemas computacionales, como ya vimos, es momento de no solo
programar en lenguajes de alto nivel, como lo hacíamos la mayoría de las veces, es la
hora de diseñar nuestro propio lenguaje de programación. Pero antes, para iniciar a
desarrollar un lenguaje se deben de conocer bien los conceptos relacionados con estos,
por eso en este portafolio veremos el contenido desarrollado en la Unidad 1, la cual trata
de la introducción a la materia de lenguajes autómatas.
Índice
Introducción general del portafolio de la unidad 1 ...................................................................... 1
Contenido........................................................................................................................................... 3
Simbolo: ..................................................................................................................................... 3
Alfabeto:..................................................................................................................................... 3
Cadena:...................................................................................................................................... 3
-Prefijos, -Sufijos, y-Subcadenas........................................................................................... 3
Lenguaje: ................................................................................................................................... 4
Algunas operaciones con lenguajes.......................................................................................... 5
Unión .......................................................................................................................................... 5
Intersección ............................................................................................................................... 5
Resta .......................................................................................................................................... 5
Concatenación.......................................................................................................................... 5
Cerradura de Klein ................................................................................................................... 5
Cerradura positiva .................................................................................................................... 5
Complemento............................................................................................................................ 5
Algunos ejercicios con propiedades de los lenguajes ............................................................ 6
Tipos de lenguajes ....................................................................................................................... 7
Proceso de traducción................................................................................................................. 7
Fases del compilador................................................................................................................. 10
Análisis..................................................................................................................................... 11
Síntesis..................................................................................................................................... 11
Anexos ......................................................................................................................................... 15

2
Tarea 1: ejercicios con operaciones de lenguajes............................................................ 15
TAREA 2: HERRAMIENTAS PARA EL DESARROLLO DE LENGUAJES (COMPILADORES DE
COMPILADORES) ....................................................................................................................... 16
Tarea 3.- Investigación referente a lenguajes de programación..................................... 21
Conclusiones generales ................................................................................................................ 36
Preguntas......................................................................................................................................... 36
Bibliografía general de este portafolio......................................................................................... 37
:

3
Contenido
Para iniciar con la materia de lenguajes autómatas, que en resumen se trata de armar con
compilador de lenguaje, que lleve nuestro lenguaje de un alto nivel a un nivel bajo o
ensamblador, es necesario conocer los conceptos básicos relacionados con el lenguaje y
el proceso de comunicación:
Para definir un lenguaje se necesita definir un alfabeto
Símbolo:
Es un objeto indivisible según Elisa Vilso, es una entidad abstracta según Hopcroft y
Ullman, también Brookshear y Dean Kelly nos dice algo semejante
Entonces se define que un símbolo es una representación escrita de algo, como por
ejemplo “}” es un simbolo
Alfabeto:
Según Elisa Vilso nos dice que es un conjunto finíto de simbolos, Dean Kelly agrega que
es la base para construir un lenguaje, Wikipedia nos dice que es un conjunto ordenado de
letras, es un conjunto de simbolos empleado en un sistema de comunicación según el
Diccionario de la Real Academia Española
Entonces un alfabeto es un conjunto de símbolos, por ejemplo, las letras, números y
signos que utilizamos para escribir, en este caso nosotros usamos el alfabeto griego.
Cabe destacar que este conjunto de símbolos es finito, es decir que está limitado o tiene
un fin. Este conjunto está ordenado y en cierta forma sabemos cuál es la secuencia. Por
ejemplo al decir A, B, C, D, E… nosotros sabemos cómo mínimo cuáles serán los
siguientes 19 símbolos.
Cadena:
Según Hopcroft y Ullman es una secuencia de símbolos yuxtapuestos que tiene un fin,
Elisa Vilso nos dice que son tomados de un alfabeto al igual que Isasi, Martinez y Borrajo
Entonces una cadena es la secuencia de 0 o más elementos concatenados entre sí, por
ejemplo “parangaricutirimicuaro” es una cadena, “w” es una cadena también aunque sea
una sola letra,”” es una cadena vacía.
Una cadena también se puede denominar como –palabra- o en ingles –string-. Las
cadenas tienen una lonitud determinada y son continuas. A su vez las cadenas tienen:
-Prefijos, -Sufijos, y-Subcadenas
Los prefijos de una cadena se forman por los primeros símbolos de esta y los sufijos por
los últimos según Hopcroft y Ullman
Un prefijo es una parte de la cadena comprendida entre la posición 0 y una posición
determinada de la cadena. Por ejemplo para la palara –automóvil-
“ξ” representa la cadena vacía y se considera un prefijo

4
“auto”, “a”, “au”, “automovi” se consideran prefijos también
“automóvil”, también se considera un prefijo.
Un sufijo es una parte de la cadena comprendida entre una posición determinada de la
cadena y la posición final
“ξ”, “móvil”, “utomovil”, “automóvil” son sufijos también
Una subcadena es una parte de la cadena comprendida entre una posición determinada
por nosotros y otra posición determinada, es decir, los límites del recorte de la cadena
pueden ser movidos, a diferencia de los prefijos y sufijos que uno de sus 2 límites es
constante
“tomovi”, “tomo”, “ξ”, “automóvil” son subcadenas de “automóvil”
Una subcadena también es la eliminación de 2 o más elementos de la cadena, pero es
importante saber que los elementos no pueden cambiar de posición, por ejemplo:
“aumo”, “atomo”, “oil”, “ml” son subcadenas de “automóvil”, pero “vilaut” que contiene
letras que se encuentran en la palabra principal no es un subcadena, ya que unos
elementos han rebasado la posición de otros elementos de la cadena “automóvil”.
Con estos conocimientos, podremos definir la palabra lenguaje
Lenguaje:
Un lenguaje es un conjunto de cadenas sobre un alfabeto define la mayoría de los
autores, el conjunto vacio y el conjunto formado por la cadena vacia son lenguajes
agregan Hopcroft y Ullman, el número de las cadenas no es determinado, ya que se
pueden formar nuevas cadenas con el tiempo, o inventar ciertas palabras.
Podemos representar un lenguaje en varias notaciones:
L= {aaaa, aabb, bbaa, bbbb}
Para describir este lenguaje observamos que está formado por todas las combinaciones
posibles de las cadenas “aa” y “bb”, y el tamaño es de 4 elementos.
L= {A, B, C, …, z}
En este caso pensaríamos que no es un leguaje, sino un alfabeto, pero recordemos que
un alfabeto puede ser un lenguaje y un símbolo puede ser una cadena.
L={an
bn
| n>0}
En este caso, esta es otra manera de representar un lenguaje, el conjunto de todas las
cadenas de [a] y [b] tal que empieze con 0 o más [a] seguidas del mismo número de [b]

5
L= { an
bm
| n, m >=0 }
= {0, a, b, aa, ab, bb, aaa, aab, ….}
Podemos describir este lenguaje similar al anterior, ya sabemos cómo hacerlo de acuerdo
al lenguaje anterior.
Algunas operaciones con lenguajes
Unión
La unión de 2 lenguajes da como resultado todos los elementos de un lenguaje y de otro,
no se pueden repetir los elementos, se representa:
𝐴 ∪ 𝐵
Intersección
La intersección da como resultado un conjunto con los elementos que estén en ambos
conjuntos simultáneamente, se representa como:
𝐴 ∩ 𝐵
Resta
En la resta se le quitan a los elementos de A, los elementos de A que estén en B
𝐴 − 𝐵
Concatenación
La concatenación de cadenas consiste en unir un símbolo o cadena de un conjunto con
un símbolo o cadena de otro conjunto, por ejemplo una manera de representar esto es:
{xy | x A y y B}
Describiendo esto decimos que es un símbolo o cadena perteneciente al lenguaje A,
unido o seguido de un símbolo o cadena perteneciente al lenguaje B
Cerradura de Klein
Es la concatenación de 0 o más elementos de un lenguaje determinado, al decir 0 o mas
elementos se incluye la cadena vacía, se representa como A*
Cerradura positiva
A diferencia de la cerradura de Klein, es la concatenación de 1 o más elementos de A. Se
representa como A+
Complemento
El complemento comprende todos los elementos que no pertenezcan a un lenguaje, se
representa como Ᾱ o A´, y formalmente lo podemos describir con esta expresión
Ᾱ={x | x no A}

6
Algunos ejercicios con propiedades de los lenguajes
Sean los lenguajes
X={A,B,….,Z,a,b,…,z}
Y={A,E,…,U,a,e,…,u,0,1,2,…,9}
Se define a [X] como el lenguaje formado por el conjunto de todas las letras mayúsculas y
minúsculas
Y se define a [Y] como el lenguaje conformado por el conjunto de todas las letras vocales
mayúsculas y minúsculas, y el conjunto de los números del 0 al 9
 𝑋 ∪ 𝑌
En este caso se juntarán los 2 lenguajes, por lo tanto el lenguaje generado es
𝑋 ∪ 𝑌 = {𝐴, 𝐵. . 𝑍, 𝑎, 𝑏, . . , 𝑧, 0,1, . .9}
 𝑌 − 𝑋 = {0,1, . .9}
 𝑋 ∩ 𝑌 = {𝐴, 𝐸, . . . , 𝑈, 𝑎, 𝑒, … , 𝑢}
 𝑋 − 𝑋 ∪ 𝑌 = { }
 𝑌 − 𝑌 ∩ 𝑌 = { }
 𝑋 ∪ 𝑌 ∗
= ξ, A, AA, AB, ABz, Bl3, 258Ufo, No, haga, examen, maestra, … . .
𝐿𝑒𝑛𝑔𝑢𝑎𝑗𝑒 𝑐𝑜𝑛𝑓𝑜𝑟𝑚𝑎𝑑𝑜 𝑝𝑜𝑟 𝑙𝑎 𝑐𝑜𝑛𝑐𝑎𝑡𝑒𝑛𝑎𝑐𝑖ó𝑛 𝑑𝑒 𝑡𝑜𝑑𝑎𝑠 𝑙𝑎𝑠 𝑙𝑒𝑡𝑟𝑎𝑠 𝑦 𝑛ú𝑚𝑒𝑟𝑜𝑠 𝑖𝑛𝑐𝑙𝑢𝑦𝑒𝑛𝑑𝑜 𝑣𝑎𝑐𝑖𝑜
 𝑋𝑌 ∗ = {ξ, AA, BE, B5, C8Ye, … , fiZ8, … . }
Lenguaje formado por el conjunto de todas las letras seguidas de una letra vocal o
un número, concatenado 0 o más veces
Otras formas de representar un lenguaje es la notación formal
𝐿 = 𝑤 𝑤 ∈ (𝑎, 𝑏)∗
}
Esta representación nos dice que [w] es el lenguaje que contiene a todas las cadenas
formadas por [a] y [b]

7
Tipos de lenguajes
Lenguaje máquina
Es el lenguaje formado por 0 y 1, que es el que la máquina entiende, en realidad
son pulsos de voltaje
Lenguaje de bajo nivel
Afirma Dean Kelly que es el lenguaje más cercano al hardware, este se
programaba en binario, agrega Brookshear que para hacer más fácil el proceso surgió un
lenguaje que incluía palabras llamado Ensamblador
Lenguaje de alto nivel
Es el lenguaje que usa palabras mas cercanas a nuestro idioma, para que la
programación de aplicaciones sea mas fácil
Proceso de traducción
El proceso de traducción de un lenguaje consiste en que de un lenguaje de programación
de alto nivel gracias a un traductor este se convierte en lenguaje máquina, tal que la
computadora lo pueda entender y hacer
En clase se vio el siguiente diagrama:
Pero en el libro de Kenneth C Louden lo manejan diferente
Se tiene la duda de si es lo mismo Compilador y Traductor
El proceso de traducción es el siguiente
Programa
Fuente
Traductor
Programa
Objeto
Programa
Fuente
Compilador
Programa
Objetivo
Leng. declarativo Macroprocesador Leng. Alto nivel Compilador
Prog.
Bajo
nivel

8
El lenguaje declarativo es el que una expresión (O Macro: “una macro es una descripción
abreviada de una secuencia repetida de texto” según Kenneth Louden) se desglosa en
varias expresiones más simples, el macroprocesador lo desglosa, después pasa por el
compilador y se convierte en un lenguaje de bajo nivel, cuando pasa por el ensamblador
este se convierte en lenguaje máquina en 0 y 1, el Ligador o Linker se encarga de ubicarlo
y lo convierte en un lenguaje máquina reubicable
Otros conceptos (Basado en los conceptos de Kenneth Louden):
Ensamblador
Un ensamblador es un traductor para el lenguaje ensamblador de una computadora en
particular. Como ya lo advertimos, el lenguaje ensamblador es una forma simbólica del
lenguaje de máquina de la computadora y es particularmente fácil de traducir. En
ocasiones un compilador generará lenguaje ensamblador como su lenguaje objetivo y
dependerá entonces de un ensamblador para terminar la traducción a código objeto.
Ligador
Tanto los compiladores como los ensambladores a menudo dependen de un programa
conocido como ligador, el cual recopila el código que se compila o ensambla por separado
en diferentes archivos objeto, a un archivo que es directamente ejecutable. En este
sentido, puede hacerse una distinción entre código objeto (código de máquina que todavía
no se ha ligado) y código de máquina ejecutable. Un ligador también conecta un programa
objeto con el código de funciones de librerías estándar, así como con recursos
suministrados por el sistema operativo de la computadora, tales como asignadores de
memoria y dispositivos de entrada y salida
EnsambladorLeng. máquinaLinker
Leng. Máquina
rehubicable

9
En que parte del software encontramos al compilador
Basado en este diagrama un compilador se encuentra en el software de sistemas en la
categoría base
Software
Aplicación
Videojuegos, Office,
Browsers, Bloc de notas,
etc.
Sistemas
Base SO, drivers
Traducción
Macroprocesadores,
compiladores,
ensambladores,
cargadores, interpretes

10
Fases del compilador
Diagrama de Kenneth C Louden

11
Análisis
Análisis léxico.- En este análisis se lee el fichero fuente y se identifica cuales son
los elementos básicos, los cuales se llaman tokens, como identificadores, signos,
paréntesis, etc, según Isasi, Martínez y Borrajo.
Los tokens son como palabras de un lenguaje natural agrega Kenneth
Análisis sintáctico.-Cuando el código se recibe en forma de tokens se realiza este
análisis para determinar la estructura del programa, se determinan los elementos
estructurales afirman la mayoría de los autores. Agrega Isasi que este análisis se realiza
por autómatas de pila
Análisis semántico.- En este análisis se analiza el significado de los símbolos, la
semántica determina el comportamiento durante el tiempo de ejecución agrega Kenneth
Síntesis
Optimizador de código fuente.- Los compiladores a menudo incluyen varias etapas
para el mejoramiento, u optimización, del código. El punto más anticipado en el 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án sólo del código fuente.
Generación de código: una vez que el análisis ha sido correcto, los compiladores
deben generar código en el lenguaje destino. Para ello, se recurre a las estructuras
generadas durante la fase de análisis, como, por ejemplo, los árboles de derivación, para
generar el código.
Optimización de código.-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
En la clase se manejó un diagrama diferente
Donde a diferencia del diagrama anterior las fases que cambian son:
Generación de código intermedio
Aquí se genera un código entre el alto y bajo nivel, donde los datos se almacenan en
variables temporales
Optimización de código
Las líneas de código son reducidas
Generación de código
En esta fase se genera el código en ensamblador
Un ejemplo de lo que hace el compilador
Sea la ecuación
Y=x+15*z/2
Análisis léxico
Primero tenemos que descomponer cada símbolo en tokens
(y, id)
(=, op.asig)
(x,id)
(+, op.aritm)
(15, num)
(*, op.aritm)
(z,id)

13
(/, op.aritm)
(2,num)
Donde id=identificador, op.aritm =operador aritmético, op.asig=operador de asignación,
num=número
Análisis sintáctico
 <asig>::=id=<exp>
Nos dice que la asignación es un id o una expresión
 <exp>=id||num||<exp><op.aritm><exp>
Nos dice que una expresión puede ser un id, un número o una expresión con un operador
aritmético con una expresión
 <op.aritm>
+||-||*||/
Un operador aritmético puede ser +,-,* o /
También podemos generar el árbol gramatical, guiándonos por la jerarquía de las
operaciones
asig
id
y
= exp
exp
x
op.aritm
+
exp
exp
exp
num
15
op.aritm
*
exp
id
z
op.aritm
/
exp
num
2

14
Análisis semántico
Aquí se verifican que los tipos de datos a utilizar sean válidos
Generación de código intermedio
Aquí los datos se almacenan en variables temporales
T1=15*z
T2=T1/z
T3=x+T2
y=T3
Optimización de código
Reducimos el código y usamos menos variables
T1=15*z
T1=T1/2
Y=x+T1
Generación de código
Se genera código en lenguaje ensamblador
Mov Ax,15
Mul z
Div 2
Add Ax.x
Mov y, Ax
asig(int)
id
y(int)
= exp(int)
exp
x(int)
op.aritm
+
exp(int)
exp(int)
exp
num
15(int)
op.aritm
*
exp
id
z(int)
op.aritm
/
exp(int)
num
2(int)

15
Anexos
Tarea 1: ejercicios con operaciones de lenguajes
Sean los lenguajes:
𝐿1 = 𝑥 𝑛
𝑦 𝑛
𝑛 ≥ 0}
𝐿2 = 𝑥 𝑛
𝑦 𝑚
𝑛 ≥ 0, 𝑚 > 0}
𝐿3 = 𝑥 𝑛
𝑦 𝑚
𝑛, 𝑚 ≥ 0, 𝑛 ≠ 𝑚}
Determinar usando la lógica matemática las siguientes operaciones:
1. 𝐿2 ∩ 𝐿3 = 𝑥 𝑛
𝑦 𝑚
𝑛 ≥ 0, 𝑚 > 0, 𝑛 ≠ 𝑚 }
2. 𝐿1 − 𝐿3 = 𝑥 𝑛
𝑦 𝑛
𝑛 > 0}
3. 𝐿2 − 𝐿1 = 𝑥 𝑛
𝑦 𝑚
𝑛 > 0, 𝑚 > 0, 𝑛 ≠ 𝑚 }
4. 𝐿3 − 𝐿1 𝐿2 = 𝑥 𝑛
𝑦 𝑚
𝑛 > 0, 𝑚 = 0}
5. 𝐿1 ∪ 𝐿3 − 𝐿2 = 𝑥 𝑛
𝑛 ≥ 0}
6. 𝐿3𝐿1 = 𝑥 𝑛
𝑦 𝑚
𝑥 𝐾
𝑦 𝐾
𝑛, 𝑚 ≥ 0, 𝑛 ≠ 𝑚, 𝐾 ≥ 0}
7. 𝐿2 ∪ 𝐿1 − 𝐿3 ∩ 𝐿2 = 𝑥 𝑛
𝑦 𝑚
𝑛 ≥ 0, 𝑚 ≥ 0, 𝑛 = 𝑚 }
8. 𝐿2𝐿1 ∩ 𝐿2𝐿3 = { }
9. 𝐿2 = {𝑥 𝑛
𝑦 𝑚
|𝑛 ≥ 0, 𝑚 = 0}
10. (𝐿3 − 𝐿1) = {𝑥 𝑛
𝑦 𝑚
|𝑛, 𝑚 ≥ 0, 𝑛 = 𝑚}
11. 𝐿1∗
= {(𝑥 𝑛
𝑦 𝑛
) 𝑧
|𝑛 ≥ 0, 𝑧 ≥ 0}
12. 𝐿1 ∩ 𝐿2 +
= { 𝑥 𝑛
𝑦 𝑛 𝑚
|𝑛 ≥ 0, 𝑚 > 0}
13. 𝐿1 ∪ 𝐿2 ∪ 𝐿3 +
= { 𝑥 𝑛
𝑦 𝑚 𝑧
|𝑛, 𝑚 ≥ 0, 𝑧 > 0}
14. 𝐿2 − 𝐿3 ∗
= { 𝑥 𝑛
𝑦 𝑚 𝑧
|𝑛, 𝑚 > 0, 𝑧 ≥ 0, , 𝑚 = 𝑛}
Describimos a L1 como el lenguaje conformado por el conjunto de [x] y [y] tal que inicie
con 0 o más [x] seguidas de 0 o más [y] tal que el número de [x] sea igual al número de [y]
Se define a L2 como el lenguaje formado por [x] y [y] que empiece por 0 mas [x] seguidas
de 1 o más [y]
Se define a L3 como el lenguaje formado por todas las cadenas con [x] y [y] tal que inicie
con 0 o más [x] seguidas de 0 o más [y] siempre que el número de [x] y [y] no sea el
mismo

16
TAREA 2: HERRAMIENTAS PARA EL DESARROLLO DE
LENGUAJES (COMPILADORES DE COMPILADORES)
Generadores de analizadores sintácticos
GNU Bison
Es un generador de analizadores sintácticos de propósito general, su tarea es convertir
una descripción gramatical para una gramatica independiente del contexto LALR en un
programa en C que analizará esta gramática. Se puede usar para generar desde un
analizador de lenguajes sensillo hasta complejos lenguajes de programación.
Es un analizador compatible con Yacc (Otro generador de compilador mas), para
comprenderlo se debe saber programar en C. 1
JAVA CUP
Java Cup es una herramienta para generar analizadores sintácticos de última generación,
similar a la herramienta YACC.
Construye un analizador de Java para gramáticas de las normas de producción y los
correspondientes fragmentos de código Java. CUP genera un archivo fuente en Java5

17
YACC
Yacc es una aplicación que sirve para generar analizadores sintácticos. Se encarga de generar el
código para el analizador sintáctico en lenguaje C.
Esta herramienta fue desarrollada por AT&AT para Unix. El analizador sintáctico generado por la
herramienta Yacc requiere de un analizador de léxico que funcione en conjunto con esta
herramienta2

18
Proceso del analizador Yacc
Generadores de analizadores léxicos
LEX
Es una herramienta para la generación de analizadores léxicos, normalmente se usa
conjuntamente con YACC para que en conjunto se generen los analizadores léxico y
sintácticos. Para LEX se introducen especificaciones de analizador léxico y como producto
devuelve el código fuente implementando el analizador léxico en C. 3
También podemos
encontrar muy parecidos como JLEX
Generadores de analizadores gramáticos
JFLAP
Es una herramienta que sirve para la enseñanza y visualización de los lenguajes formales.
Permite crear, operar gramáticas y expresiones regulares sobre autómatas finitos.
Es una herramienta implementada en Java que se puede descargar gratuitamente desde
el sitio www.jflap.org. 4

19
COCO/R
Es una herramienta que nos sirve para generar un analizador de gramática, genera un
escanner y un programa que analizará el idioma. El escáner funciona como un autómata
finíto determinista, utilizando descenso recursivo.
Existen versiones de esta herramienta para C y Java. Puede trabajar en conjunto con otras
herramientas como Lex y Yacc.
El usuario tiene que agregar módulos para el manejo de la tabla de símbolos, optimización
y generación de código con el fin de conseguir un compilador de ejecución. Coco / R
también se puede utilizar para construir otras sintaxis basadas en aplicaciones que tienen
menos de un "compilador" sabor que un analizador para un lenguaje de programación.6
Generadores de múltiples analizadores
ANTR
ANTLR es un programa que está escrito en JAVA, por lo que se necesita alguna máquina
virtual de JAVA para poder ejecutarlo. Es software libre, lo que quiere decir que al
descargarlo de la página oficial (http://www.antlr.org) obtendremos tanto los ficheros
compilados *.class como el código fuente en forma de ficheros *.java.
ANTLR es un generador de analizadores. Mucha gente llama a estas herramientas
compiladores de compiladores.
ANTLR es capaz de generar un analizador léxico, sintáctico o semántico en varios lenguajes
(java, C++ y C#) a partir de unos ficheros escritos en un lenguaje propio. Dicho lenguaje es
básicamente una serie de reglas EBNF y un conjunto de construcciones auxiliares.7
Otras herramientas
 Editores de estructuras: Un editor de estructuras toma como entrada una secuencia de
órdenes para construir un programa fuente. Puede comprobar si la entrada, puede
proporcionar palabras clave de manera automática.
 Impresoras estéticas: Una impresora estética analiza un programa y lo imprime de forma
que la estructura del programa resulte claramente visible.
 Verificadores estáticos: Un verificador estático lee un programa, lo analiza e intenta
descubrir errores potenciales sin ejecutar el programa. Un verificador estático puede
detectar si hay partes de un programa que nunca se podrán ejecutar o si cierta variable se
usa antes de ser definida.

20
Conclusión TAREA 2:
En conclusión hemos visto que estas herramientas crean un analizador para nuestro
lenguaje, la mayoría están diseñadas para trabajar en un entorno con C, y otras con Java,
que son los lenguajes más utilizados. Ya que no todos los lenguajes de programación
satisfacen nuestras necesidades, nosotros podemos crear uno, y estas herramientas
facilitan el diseño de nuestro compilador
Bibliografía TAREA 2:
1
Donnelly Charles, Stallman Richard. El Generador de Analizadores Sintácticos compatible con
YACC (1999, 12 de febrero). [en línea]. Disponible en: http://es.tldp.org/Manuales-
LuCAS/BISON/bison-es-1.27.html
2
S. C. Johnson, Yacc: Yet Another Compiler Compiler, Computing Science Technical Report No. 32,
1975, Bell Laboratories, Murray Hill, NJ 07974.
3
Lesk, Schmidt. Lex(2005) – A Lexical Analyzer Generator [En línea]Disponible en:
http://dinosaur.compilertools.net/lex/
4
Scott E (1999). CUP User´s Manual [En línea], Hudson Graphics Visualization and Usability Goegia
Institute of Technology. Disponible en: http://www.cs.princeton.edu/~appel/modern/java/CUP/
5
Hanspeter Mössenböck , Markus Löberbauer , Albrecht Woss (2011). El generador de compilador
Coco / R [En línea]. Universidad de Linz. Disponible en: http://www.ssw.uni-linz.ac.at/coco/
6
http://www.uco.es/~ma1fegan/Comunes/manuales/pl/ANTLR/Introduccion-ANTLR.pdf

21
Tarea 3.- Investigación referente a lenguajes de
programación
Introducción
En este trabajo analizaremos el alfabeto, lenguaje y la sintaxis básica de 3
lenguajes de programación. En si las palabras que pueden tener estos lenguajes
son muy variadas, así que no es posible ponerlas todas en este trabajo. Pero
como sabemos todos los lenguajes de programación tienen un alfabeto propio, y
con este formamos el lenguaje. Y el acomodo de los componentes es la sintaxis
del lenguaje de programación.
En este caso se analizarán 3 lenguajes de alto nivel: FORTRAN, PASCAL y
JAVASCRIPT

22
FORTRAN
Fortran es un lenguaje de alto nivel, diseñado principalmente para aplicaciones
matemáticas y de ingeniería, es de propósito general, ya que se pueden hacer distintas
aplicaciones.
Entre sus características más relevantes de este lenguaje aparecen, como ya vienen
siendo habituales el soporte de localización de los programas o computación paralela, y
otras como soporte de notación matemática, comprobación estática de tipos en arrays y
matrices multidimensionales, o definición en las librerías de sintaxis del lenguaje
específico para ciertos dominios.
Alfabeto:
Letras:
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
a b c d e f g h i j k l m n o p q r s t u v w x y z
Números:
0 1 2 3 4 5 6 7 8 9
Caracteres especiales:
+ - * / ( ) , . ' : ! " % & ; < > ? $ _
Lahey/Fujitsu(1995). LF Fortran 95 Language
Reference [En línea]. Disponible en : http://www.lahey.com/docs/lang_revg.pdf
El lenguaje Fortran no distingue en la sintaxis las letras mayúsculas y minúsculas salvo en
el caso de los literales, y los signos de la comparación no los suele utilizar.
-No existen palabras reservadas como tal, sino palabras clave, sabiendo que cualquier
palabra puede ser un identificador valido.
-El número máximo de caracteres que se pueden utilizar son 31, aunque el compilador
solo reconoce los seis primeros.
-El nombre de los objetos debe tener un significado sobre el objeto que se está tratando
(Que tenga sentido), se debe hacer una normalización de los nombres.

23
Lenguaje y palabras clave
En general el lenguaje se compone por las palabras compuestas de la concatenación de
las vocales y los números, y otros elementos del alfabeto, por todos los elementos del
alfabeto y las palabras clave que veremos a continuación:
Tipos de Módulo:
PROGRAM, FUNCTION, SUBROUTINE, BLOCK DATA
Tipos de dato
INTEGER*N .-Asigna N bytes al entero, N=número entero
REAL*N .-Real con N bytes
COMPLEX*N
CHARACTER*N .- Carácter
LOGICAL*N .- Lógico
Implementación de registro
RECORD
Contantes: PARAMETER
Datos: DATA
Operadores:
- (Operador potencia).
-/ (Operador división real).
-* (Operador producto).
-- (Operador resta).
-+ (Operador suma).
-() (Paréntesis).
En fortran no se pueden usar: -<=, >=, <, >, <> como operadores
-.LT. (Operador menor que).
-.LE. (Operador menor o igual que).
-.NE. (Operador distinto de).
-.GT. (Operador mayor que).
-.GE. (Operador mayor o igual que).
-.EQ. (Operador igual que).

24
-.NOT. (Operador negación).
-.AND. (Operador producto lógico).
-.OR. (Operador suma lógica).
-.XOR. (Operador suma exclusiva lógica).
-.EQV. (Operador de equivalencia lógica).
-.NEQV. (Operador de no equivalencia lógica).
Declaración de variables: IMPLICIT
Final de programa: STOP, END
Entrada y salida de datos: READ, PRINT, WRITE
Matemáticas:
sin(rd), cos(rd), tan(rd), asin(rd), acos(rd), atan(rd), atan2(rd,rd), sqrt(rd), exp(rd), log(rd),
log10(rd), abs(ird), mod(ird,ird), int(ird), real(ird), dble(ird)
Condicionales
IF, ELSE, ENDIF
Iteraciones
DO, ENDDO, WHILE
Retornos
RETURN
Sintaxis
Estructura general de programa:
Sintaxis de parámetros
Asignación
Variable=expresión
Sintaxis de lectura y escritura

25
Sintaxis para condicionales
Bucles:
Ejemplo de un programa en FORTRAN
-------------------------------------------------------------
-----
Se calculan las raíces de la ecuación cuadrática
ax**2+bx+c=0-------------------------------------------------
-----------------
Bloque de declaración de tipos-------------------------------
-----------------------------------
implicit none
double precision a,b,c
! coeficientes de la ecuación
double precision discr

26
! discriminante de la ecuación
double precision x1,x2
! variables para soluciones
-------------------------------------------------------------
-----
Entrada de datos
-------------------------------------------------------------
-----
write(*,*) ’Ingrese coeficientes a,b,c’
read(*,*) a,b,c
if(a.eq.0.0d0) then
write(*,*) ’La ecuación no tiene término cuadrático’
stop
endif
-------------------------------------------------------------
-----
Bloque de procesamiento y salida
-------------------------------------------------------------
-----
discr = b**2 - 4.0d0*a*c
den
= 2.0d0*a
term = sqrt(abs(discr))
if (discr.ge.0.0d0) then
x1 = (-b+term)/den
x2 = (-b-term)/den
write(*,*) ’x1 = ’, x1
write(*,*) ’x2 = ’, x2
else
x1 = -b/den
x2 = term/den
write(*,*) ’x1 = (’, x1, ’ ,’, x2, ’)’
write(*,*) ’x1 = (’, x1, ’ ,’, -x2, ’)’
endif
-------------------------------------------------------------
-----
Terminar
-------------------------------------------------------------
-----
stop
end

27
PASCAL
ALFABETO:
El alfabeto de PASCAL se compone por:
-Las letras mayúsculas y las minúsculas desde la " A " a la " Z " y desde la " a " a
la " z ".
-los números del " 0 " al " 9 ".
-Caracteres especiales
- Caracteres no imprimibles, tales como el espacio en blanco, el tabulador, el salto de
linea, el retorno de carro, etc.
LENGUAJE
En general el lenguaje de pascal se compone por la concatenación de varios elementos
del alfabeto, incluyendo el alfabeto en general, generalmente las concatenaciones se dan
más en letras y números. En general, los compiladores de PASCAL no distinguen entre
letras mayúsculas y minúsculas excepto cuando se escriben entre apóstrofos.
Palabras reservadas estándar
{AND, ARRAY, BEGIN, CASE, CONST, DIV, DO, DOWNTO, ELSE,

28
END, FILE, FOR, FUNCTION, GOTO, IF, IN, LABEL, MOD,
NIL SET, NOT, THEN, OF, TO, OR, TYPE, PACKED, UNTIL, PROCEDURE, VAR,
PROGRAM, WHILE, RECORD, WITH, REPEAT}
Identificadores
{ABS, ARCTAN, BOOLEAN, CHAR, CHR, COS, DISPOSE, EOF, EOLN, EXP, FALSE,
GET, INPUT, INTEGER, LN, MAXINT, NEW, NIL, ODD, ORD, OUTPUT, PACK, PAGE,
PRED, PUT, READ, READLN, RESET, REWRITE, ROUND, SIN, SQR, SQRT, SUCC,
TEXT, TRUE, TRUNC, UNPACK, WRITE, WRITELN}
SINTAXIS
Un programa escrito en PASCAL se compone por el encabezado y el bloque
En el encabezado se especifica el nombre del programa y los nombres de los ficheros
externos que se usan para entrada de datos y salida de resultados.
El bloque está dividido en dos partes:
. La sección de las declaraciones, donde se declaran todos los datos y las rutinas.
. La sección ejecutable, que contiene sentencias ejecutables.
Un programa también puede contener líneas de comentario intercaladas en cualquier
lugar.
Sintácticamente, un programa comienza con la palabra PROGRAM y termina con un
punto "."
REGLAS SINTÁCTICAS
 El punto y coma ( ; ) y el punto ( . ) son DELIMITADORES en PASCAL.
 Las palabras BEGIN y END también son delimitadores, no son sentencias.
 El PASCAL permite formato libre en la escritura del texto que compone el
programa.
 Un programa puede tener comentarios en cualquier parte. Los comentarios se
delimitan encerrándolos entre llaves ( { } ). También es posible comenzar un
comentario con " (* " y acabarlo con " * ) ".
Ejemplo de estructura del programa:

29

30
JAVASCRIPT
Es un lenguaje orientado a objetos, con mas utilidad en navegadores web, es de alto
nivel.
Alfabeto de Java Script
Letras:
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t
u v w x y z 0 1 2 3 4 5 6 7 8 9 + - * / ( ) , . ' : ! " % & ; < > ? $ _
El alfabeto de Javascript es muy similar al de los otros lenguajes de alto nivel
Lenguaje y palabras reservadas
Los tipos de datos que maneja Javascript son
String, Boolean y Number
Operadores de cálculo:
-, ++, --, *, /, %, +, -
Operadores lógicos Operadores comparativos Otras palabras

31
Palabras reservadas de Javascript
Java script al igual que muchos lenguajes tiene sus palabras reservadas, las cuales no
pueden ser usadas como nombre de identificadores
{Break, delete, if, this, while, case, do, in, throw, with, catch, else, instanceof, try, continue,
finally, new, typeof, debugger, for, return, var, default, function, switch, void}
A su vez habrá palabras reservadas para uso futuro
1. class
2. const
3. enum
4. export
5. extends
6. import
7. super
8. implements
9. interface
10. let
11. package
12. private
13. protected
14. public
15. static
16. yield
SINTAXIS
La sintaxis de javascript en un document html comienza y cierra con las etiquetas
<SCRIPT></SCRIPT>
<HTML>
<HEAD>
<TITLE>PRUEBA 1 </TITLE>
<SCRIPT>
var globalvar1=5;
Function multiplica()
{
var localvar1=2 * globalvar1;
alert("Dos por cinco son= " + localvar1);
}
</SCRIPT>
</HEAD>
<BODY BGCOLOR="#00AA00" TEXT="#FFFFFF" LINK="#0000FF"
VLINK="#0000FF" ALINK="#0000FF" onLoad=multiplica()>
<CENTER><H1> Esto es un ejemplo</H1></CENTER>
</BODY>
</HTML>

32
Declaración de variables
var a = 15;
var b = "gato";
Para declarar variables primero se pone el tipo de dato que es, el identificador, el signo de
asignación, el valor y punto y coma. Si la variable es cadena se encierra en “”
También se puede decir cuando será decimal, octal y hexadecimal de esta manera:
var numeroDecimal = 17; // 17 en decimal
var numeroOctal = 021; // 17 en octal, se indica con un 0 delante
var numeroHexadecimal = 0x11; // 17 en hexadecimal, se indica con 0x delante
Sintaxis de los operadores aritméticos
var total = sumando1 + sumando2;
// asigna a total la suma
// de las otras dos variables
var total = minuendo - sustraendo;
// asigna a total la resta
var total = factor1 * factor2;
// asigna a total el producto
var total = dividendo / divisor;
// asigna a total el cociente
var total = dividendo % divisor;
// asigna a total el resto
// de la división de las dos variables
Sintaxis de operadores comparativos
variable1 +operador lógico+ variable2:
variable1 > variable2
Sintaxis operadores lógicos
!condición1
(condición1)&&(condición2)
(condición1)||(condición2)
Sintaxis Comparación (ejemplo):

33
if(condición){
…enunciados a ejecutar si se cumple la condición…
} else {
…enunciados a ejecutar si NO se cumple la condición…
}
Switch:
switch (variable){
case(valor1):
…enunciados a ejecutar para ese valor…
break;
case(valor2):
break;
case(valor3):
break;
default:
…enunciados a ejecutar cuando el valor no
coincida con ninguno de los anteriores…
break;
}
Sintaxis ciclos:
for(contador;condición;variación_del_contador){
…enunciados a ejecutar…
}
Sintaxis función:
function nombre_de_la_función(){
…enunciados a ejecutar…
}
http://www.codexexempla.org/curso/curso_4_2_b.php#op-comparativos
También en la sintaxis tenemos los siguientes puntos:
 No se tienen en cuenta los espacios en blanco y las nuevas líneas
 Se distinguen las mayúsculas y minúsculas
 No se define el tipo de las variables: al hacer una variable no es necesario poner que
tipo de variable es
 No es necesario terminar cada sentencia con el carácter de punto y coma (;)
 Se pueden incluir comentarios

34
Conclusión
Como vimos en esta investigación, nos hemos dado cuenta que los 3 lenguajes
tienen muchas características en común, por ejemplo el alfabeto es muy parecido
en los 2. La sintaxis de algunos condicionales también es bastante semejante.
Pero también encontramos diferencias, por ejemplo, en unos lenguajes al declarar
las variables se tiene que poner qué tipo de variable estamos declarando, en otro
como javascript la variable es automáticamente identificada, y no es necesario
poner punto y coma al final de la sentencia.
Otra diferencia importante en estos lenguajes es el paradigma de programación,
unos son de programación estructurada y otros se centran en los objetos, con el
nuevo paradigma de objetos aparece mucho la palabra class.

35
Bibliografía:
1
http://lenguaje-fortran.wikispaces.com/caracter%C3%ADsticas
2
Martínez Baena, Javier; Requena Ramos, Ignacio; Marín Ruiz. Programación
estructurada con Fortran 90 / 95. Editorial Universidad de Granada, 1995.
3
Salas Ayape (1988). LA PROGRAMACION EN LENGUAJE PASCAL [En línea].
Consultado en 2013. CENTRO DE CALCULO UNIVERSIDAD DE ZARAGOZA.
Disponible en:
https://docs.google.com/viewer?a=v&q=cache:XUOJjnSgGZsJ:www.unizar.es/sicu
z/siscen/doc/ccuz19.pdf+&hl=es&gl=mx&pid=bl&srcid=ADGEESh82js0wHmRNaU
aK5qGE6zlJkGalUcq8FORTCQs8K44cRh1tUsuXdBrUyKhRCB7R-
4MYMYKPXol8Vb-F48z_VmHTRcy841-
CH1z3o6Yv1haMb89AgWkC16NyAkhmKpxgqPDclJf&sig=AHIEtbQBCq2TgCJ_m
S41sHfeh6igjr_fyw
4
Nicholas C. Zakas (2009), Professional JavaScript for Web Developers (En línea).
Disponible en: http://msdn.microsoft.com/es-es/library/7wkd9z69(v=vs.94).aspx
5
Christian Johansen. Test-Driven JavaScript Development (Developer's Library).
(2011). ADDISON WESLEY

36
Conclusiones generales
Como hemos visto aquí se ha visto la teoría introductoria para construir un compilador, el
proceso que sigue este programa para convertir de un tipo de lenguaje a otro para que la
máquina lo entienda. La importancia de saber los conocimientos para generar un lenguaje
de programación es grande para un ingeniero en sistemas, ya que ciertos lenguajes no
nos pueden satisfacer o se nos puede ocurrir un mejor lenguaje para resolver ciertos tipos
de problemas, si sabemos cómo crear este lenguaje aparte de ser útil para nosotros para
muchas otras personas es útil un nuevo lenguaje.
Aprendimos que se pueden realizar operaciones con conjuntos, pero también,
operaciones matemáticas con lenguajes, también a definirlos y describirlos. Todo este
conocimiento es la base para las futuras unidades de la materia de lenguaje autómatas
Preguntas
1. ¿Cuál es el trabajo que consideras mas difícil a la hora de hacerlo y porqué?
Considerando las tres tareas, el trabajo más difícil fue la tarea número 3 que consistía
en obtener el alfabeto, lenguaje y sintaxis de 3 lenguajes de programación, ya que los
lenguajes de programación tienen muchas palabras reservadas y muchas estructuras
de sintaxis, otra complicación fue que a pesar de que existen muchos lenguajes de
programación, solo venia información de una pequeña parte de ese conjunto, los
cuales son los lenguajes más populares.
2. ¿Cuál de las tareas realizadas consideras más significativa o que te aportó
más para comprender la unidad?
La tarea número 1 que consistía en ejercicios, ya que en esa tarea se usa la lógica
para crear nuevos lenguajes a partir de otros existentes, y se aprendió como
representar esos lenguajes en notación formal
3. ¿Cuál de las tareas realizadas consideras más sencilla y porqué?
La tarea número 1, ya que usando bien la lógica se hizo en menos de una hora

37
Bibliografía general de este portafolio
 Hopcroft, Ullman (1993). Introducción a la teoria de autómatas, lenguajes y
computación. Editorial CECSA
 Isasi, Martinez, Borrajo (1997). Lenguajes, gramáticas y autómatas, un
enfoque práctico. México. Editorial Addison-wesley
 Brookshear. Teoría de la Computación, Lenguajes Formales,Autómatas y
Complejidad. Addison Wesley.
 Viso (2002). Teoria de la computación. México. Facultad de Ciencias UNAM
Louden (2004). Construcción de compiladores, principios y práctica. Ed Thomson
 Kelley, Dean, Teoría de Automatas y Lenguajes Formales, Prentice Hall.

Portafolio Lenguajes y Autómatas Unidad 1

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Semelhante a Portafolio Lenguajes y Autómatas Unidad 1

Semelhante a Portafolio Lenguajes y Autómatas Unidad 1 (20)

Mais de Humano Terricola

Mais de Humano Terricola (9)

Último

Último (20)

Portafolio Lenguajes y Autómatas Unidad 1