Universidad de San Carlos de Guatemala

Faculta de Ingeniería
Escuela de Ciencias y Sistemas
Lenguajes Formales y de Programación A+
Ing. Otto Rodríguez
Aux. Fabelio Ajtún
Segundo semestre 2015

Proyecto No. 1
Objetivos
 Que el estudiante aplique los conceptos adquiridos en las clases magistrales, acerca de la
construcción de un compilador. 
 Que el estudiante pueda construir la primera fase de un compilador, pudiendo identificar
lexemas, de un lenguaje de programación, contenidos en un archivo. 
 Aplicar el método del árbol para diseñar un Autómata Finto Determinísticos, a partir del cual se
programe un analizador léxico. 

Descripción
El proyecto consiste en desarrollar un analizador léxico y sintáctico, para el reconocimiento del lenguaje
de simulación empleado para programar montacargas automatizados, que deben realizar ciertas tareas
de traslado de los objetos ubicados en el almacén.

Manejo de archivos
El proyecto debe permitir leer un archivo que contendrá la secuencia de acciones que se desea ejecute
cada montacargas, estos archivos tendrán la extensión .lfp. El programa debe permitir ingresar la
ubicación y nombre del archivo de entrada, y luego ejecutarlo.

Panel de control
El panel de control consiste en una consola dentro de la aplicación, en la cual existirán dos áreas
independientes en las cuales el usuario podrá:

1. Ingresar instrucciones: en esta área el usuario podrá ingresar cualquiera de las instrucciones que
se describen más adelante, para luego ser ejecutadas.
2. Mostrar errores: en esta área el usuario recibirá las notificaciones de los errores lógicos que
ocurran durante la ejecución de alguna instrucción. Las instrucciones que generan reporte de
errores se detallan a lo largo del enunciado.

NOTA: Todos los mensajes de error y advertencia, que se envía al Panel de Control, también deben
escribirse en un archivo tipo texto, que tendrá como nombre de archivo lo siguiente: Salida-<carnet>.txt
Lenguaje de programación
El archivo debe empezar con la palabra PROGRAMA seguido de un nombre que lo identifica. Las
palabras en mayúsculas y minúsculas son equivalentes, por lo que es lo mismo PROGRAMA, programa o
programa.

Bloque de declaración
Este bloque iniciara con la palabra VARIABLES y será la única área en la que se permitirá la declaración
de variables. Este bloque contendrá:

1. Declaración de Variables: El sistema puede manejar los siguientes tipos de variables: Entero,
Cadenas, Montacargas, y Carga. La sintaxis es:

identificador tipo;

No se acepta más de una variable por declaración, es decir, solamente se puede declarar una a
la vez.

Esta sección debe aparecer antes del bloque de programación identificado por las palabras INICIO, FIN.

Bloque de programación
Este bloque debe aparecer luego del bloque de declaración de variables, y estará delimitado por las
palabras INCIO y FIN. Dentro de este bloque se podrán incluir las siguientes instrucciones:

1. Comentarios: En cualquier momento se pueden colocar comentarios dentro del código del
programa. Los comentarios pueden ser de dos tipos:

a. De una sola línea: estos comentarios iniciaran con la secuencia ## a la cual le puede
seguir cualquier cantidad de caracteres, excepto el salto de línea. Ejemplo:
##comentario1

b. Multilinea: estos comentarios inician con la secuencia {-- y terminan con la secuencia --}
dentro de las cuales puede venir cualquier cantidad de caracteres incluyendo el salto de
línea. Ejemplo: {-- comentario2 --}

2. Mapa: Consiste en el área donde el montacargas podrá movilizarse. Está representado

mediante una ventana con coordenadas x y y. La esquina inferior izquierda representa la
coordenada (0,0). El mapa pueden ser mayor que la ventana que los muestra o incluso de la
pantalla completa, por lo que para poder desplegarlos en pantalla, debe permitir realizar
“scroll” (desplazamiento).

El mapa se puede crear en tiempo de ejecución mediante la instrucción Mapa(nombre,x,y)

donde x,y son valores enteros que pueden ser variables o constantes y representan el tamaño x,
y del mapa; nombre representa el identificador del mapa y puede ser una variable o constante
tipo cadena. Solamente un mapa se puede crear por programa, si se trata de crear otro mapa,
deberá mostrar un error en el Panel de Control, y seguir con el resto de instrucciones.
 3. Obstáculos: Dentro del mapa pueden haber diferentes obstáculos, y son creados mediante la
instrucción obstaculo(x, y) donde (x, y) indica la coordenada del mapa donde se debe colocar. Si
no se ha creado un mapa aún, se debe mostrar un mensaje de error al panel de control. De igual
manera, si se crea en una coordenada fuera del mapa, debe enviar un mensaje de error al panel
de control y ejecutar las instrucciones siguientes.

4. Carga: Consiste en cualquier objeto que el montacargas debe cambiar de lugar. La carga se crea
mediante la instrucción C:=DefineCarga(Color, cantidad, x, y) donde x,y son las coordenadas en
el mapa, cantidad es la cantidad de objetos a movilizar (en pantalla solo el símbolo) y Color es el
color que debe tener la carga para ser identificada en el mapa. Los colores posibles son verde,
azul, naranja y amarillo. C es una variable de tipo carga que es iniciada con la instrucción
DefineCarga y := es el operador de asignación. Al colocar el mouse encima de una carga, debe
indicar cuántos objetos que contiene. Si se crea en una coordenada del mapa que no existe, se
debe enviar un error al panel de control y seguir con la ejecución.

5. Numero: Numero es una función que devuelve el número de objetos que aún no han sido
tomados de la carga creada. N := Numero(C ) ; donde N es una variable de tipo entero, y C es
una variable de tipo carga.

6. Montacargas: Son los encargados de realizar las tareas, funciones o movimientos indicados en
el programa, deben moverse a través del mapa. Los montacargas son creados por la instrucción
M:=CreaMontacargas(Identificador, x, y) donde identificador es el Id del montacargas; x, y es la
coordenada donde inicia el montacargas en el mapa. Si se inicia en una coordenada del mapa
que no existe, se debe enviar un error al panel de control, indicando que montacargas genero el
error, y luego seguir con la ejecución.

NOTA: Los obstáculos, cargas y montacargas deben ser identificados de manera única dentro del mapa a
través de iconos gráficos.

Operaciones algebraicas
Dentro del programa se pueden realizar operaciones algebraicas (suma, resta, multiplicación y división)
sobre las variables y constantes del tipo entero. La sintaxis es:

Operación Ejemplo
Suma operador1 + operador2
Resta operador1 - operador2
Multiplicación operador1 * operador2
División operador1 / operador2
Para la realización de estas operaciones, se debe tomar en cuenta la presidencia de los operadores ya
que se podrán realizar operaciones que incluyan más de un operador.
Operaciones sobre los montacargas:
Los montacargas se puede mover en cuatro direcciones, y detenerse en determinada posición; las
operaciones de movimiento son las siguientes:

1. IZQUIERDA(M,n) El montacargas M se mueve n posiciones a la izquierda.

2. DERECHA(M,n) El montacargas M se mueve n posiciones a la derecha.
3. ARRIBA(M,n) El montacargas M se mueve n posiciones a la derecha.
4. ABAJO(M,n) El montacargas M se mueve n posiciones a la derecha.
5. DETENER(M,n) El montacargas M se detendrá n segundos antes de continuar. Cuando un
montacargas realiza la acción DETENER, debe cambiar a color rojo, durante el tiempo indicado.
Esta instrucción solamente podrá ser enviada en tiempo de ejecución, a través del panel de
ejecución.

Al momento en el que el montacargas ejecuta cualquiera instrucción de movilización, debe colocar el

carácter H en la coordenada donde inició, en el momento de llegar a la coordenada final; al ejecutar la
siguiente instrucción este carácter desaparece.

Si no existe un camino, porque se está tratando de mover fuera del mapa, o hay un obstáculo, el
montacargas se queda detenido hasta el máximo donde pueda llegar y debe enviar un mensaje
informativo en el panel de control. El programa debe seguir con el resto de instrucciones. Si en la
coordenada donde el montacargas debe detenerse, existe otro montacargas, debe colocarse una
coordenada antes y enviar un mensaje informativo al panel de control.

Todos los mensajes enviados al panel de control, deben indicar el Id del montacargas que los genera.

Tomar: Si el montacargas está colocado en una coordenada donde hay objetos que cargar, puede tomar
uno; solamente puede tomar uno a la vez. Si trata de tomar un objeto en una coordenada donde no hay
objetos debe dar un mensaje de error, al igual que si trata de tomar un objeto cuando ya tiene uno. Al
tomar un objeto se debe reducir el número de objetos en esa coordenada. La operación para tomar
objetos es Tomar(M); Donde M es una variable de tipo montacargas que se tiene ya creada.

Dejar: Cuando un montacargas tiene un objeto tomado, puede dejarlo mediante la instrucción dejar.
Dejar(M). Esto deja el objeto en la coordenada en la que se encuentra. Esto incrementa el número de
objetos dejados en esa coordenada. Si se dese dejar un objeto en una coordenada que contiene carga
de un color diferente, debe notificarse en el panel de control que se realizara el cambio de color de la
carga que se está dejando.

Numero Dejado: La función NumeroDejado(x,y), retorna un valor entero que indica cuántos objetos se
han colocado en la coordenada x,y.

Estado: La instrucción Estado(M) da el estado del montacargas M, escribiendo en el panel de control, el

nombre del montacargas, el número de objetos que ha cargado hasta ese momento y la coordenada
actual donde se encuentra. Realiza una pausa y el programa continúa hasta que el usuario presione una
tecla.
Ciclos y estructuras de control:
Instrucción Repetir: Esta instrucción funciona de la misma forma que el ciclo Do While de cualquier
lenguaje de programación. Permite repetir las instrucciones dentro de su estructura hasta que se
cumpla una condición específica, esta condición únicamente puede ser de igualdad. La sintaxis es:

Repetir
Instrucciones
Hasta (condición);

Instrucción Si: Esta instrucción funciona de la misma forma que el comando If de cualquier lenguaje de
programación. La condición solamente puede ser de igualdad y se pueden comparar funciones, variables
o constantes. El resultado de la condición debe ser verdadero o falso. Dentro de una instrucción de
condición, puede venir cualquier cantidad de otras instrucciones (incluso más instrucciones de
condición). Si la condición es falsa, se debe ejecutar las instrucciones dentro del bloque Sino. La sintaxis
es:

Si (condición) entonces Si (condición) entonces

Instrucciones Instrucciones
Sino FinSi
Instrucciones
FinSi

Errores
El programa debe validar errores dentro del archivo antes de proceder a ejecutar las instrucciones, De
existir errores se debe desplegar un mensaje al usuario y mostrarle la lista de errores encontrados. Los
errores se deben mostrar en un archivo HTML con nombre carné_err.html, el cual debe poder abrirse
desde la aplicación, y tendrá la siguiente estructura:

Tipo Error Descripción Línea Columna Archivo

Léxico El carácter @, no es parte del alfabeto del 4 19 Prueba1.lfp

lenguaje

Sintáctico Se esperaba un id en el nombre de la variable y 28 11 Prueba1.lfp

se obtuvo una cadena
Tokens
El programa debe generar un archivo HTML, que debe ser abierto desde la misma aplicación, en donde
se muestre el listado de tokens reconocidos durante el proceso de análisis léxico. De cada uno de los
tokens reconocidos se bebe indicar el token, lexema, tipo, línea y columna de donde fue reconocido. El
archivo HTML debe tener el nombre carne_tok.html.

Token Tipo Lexema Línea Columna

2 Palabra Programa 1 1
Reservada
1 ID Entrada1 1 10
19 Signo de ; 1 18
puntuación
3 Palabra Variables 2 1
Reservada
1 ID M1 3 2
10 Cadena ‘Almacen1’ 7 7

Editor de Texto
El editor de texto debe mostrar el número de línea para que al momento de encontrar algún error,
luego del análisis, estos puedan ser localizados de forma sencilla. Además debe generar un coloreador
de sintaxis para ciertos tokens, por medio de un scanner que debe implementar para que realice esta
funcionabilidad, de acuerdo a la siguiente tabla:

Tipo Token Color Ejemplo

Palabras Repetir, Hasta Morado Repetir, REPETIR, hasta
Palabras Si, Entonces, Sino, Rojo Si, ENTONCES, SINO, FINsi
FinSi
Demás palabras reservadas Negro Variables, Inicio, Mapa
Id Café ENTRADA1, M1, A
‘Cadenas’ Verdes ‘almacen1’, ‘azul’
Comentarios Gris Claro {--comentario1--}
##Comentario2
Signo de asignación y Naranja :=,+,-,*,/
operadores numéricos
Números Azul 12, 30, 8, 9

Reporte
El programa, en cualquier momento, le permitirá al usuario generar un reporte de la situación actual del
almacén. Este reporte consiste en la generación de un nuevo archivo .lfp en el cual se deben generar
todas las instrucciones necesarios, en el mismo lenguaje de programación del proyecto, para almacenar
el estado de cada uno de los objetos dentro del mapa (cargas, montacargas y obstáculos). El programa
debe permitir elegir la ubicación y nombre del archivo a generar.
Entregables
El proyecto se dividirá en dos fases. La primera fase constara únicamente del análisis léxico y la segunda
fase será la realización del análisis sintáctico y ejecución de las instrucciones. Los entregables para cada
una de las fases son:

Fase 1:
Esta fase consistirá en dos entregables, los cuales se detallan a continuación:

Entregable 1:
Se debe entregar un documento PDF, con el nombre [LFP]DocFase1_#carnet.pdf. Este
documento contendrá el análisis a partir del la cual se programara el analizador léxico, este
análisis consiste en: 

1. Las expresiones regulares completas que se deben utilizar en la solución.

2. El método del árbol completo. Presentando el árbol, la tabla de la función siguiente, la
matriz de transiciones y todo el procedimiento detallado.
3. Tabla de tokens, la cual consiste en una tabla donde se indica que numero de token se
le asignó a cada patrón del lenguaje.

Esta fase se debe de enviar por correo:

 Correo: fabelioajtun@hotmail.com
 Asunto: [LFP]DocFase1_#carnet
 Fecha: Sábado 29 de agosto, antes de las 11:59 pm.

Entregable 2:
En este segundo entregable el programa debe contener las siguientes funcionabilidades:

1. Generar y mostrar el listado de tokens

2. Generar y mostrar el listado de errores
3. Colorear el texto introducido en el editor de texto.

Se entregara en un disco que contendrá: 

 La documentación entregada en el entregable 1
 Código fuente
 Ejecutable
 Manual de usuario
 Manual técnico

Fecha de entrega:
Sábado 12 de septiembre de 2015

Fase 2:
Los entregables para la fase 2 se especificaran en un posterior enunciado.
Condiciones para la elaboración y entrega del proyecto:
 El lenguajes a utilizar es Visual Basic .NET 2008 en adelante 
 El proyecto es individual 
 Los nombres de todos los archivos fuente deben de tener el siguiente patrón: nombre-
archivo_carnet.xxx 
 Copia parcial o total del proyecto tendrán una nota de cero (0) puntos y se notificará a la
escuela para que se apliquen las sanciones correspondientes. 
 La forma en que se analizarán los archivos es a través de autómatas finitos determinísticos,
obtenidos por el método del árbol. 
 No se permite el uso de clases propias del framework de visual estudio, como Split o regExp
 entre otras, para la implementación del scanner. 
 No hay Prorroga.
Ejemplo de un archivo de entrada:
PROGRAMA ENTRADA1; {-- nombre del programa --}
Variables {-- declaración de variables --}
M1 MONTACARGAS;
A ENTERO;
objetos Carga;
nombre Cadena
INICIO
Mapa(‘almacen1’, 5,9); {-- crea el mapa --}
Objetos := DefineCarga (‘azul’,0,8); {-- crea los objetos a mover--}
M1:=Creamontacargas(‘Montacargas1’, 0, 0); {-- crea el montacargas --}
A := 0;
{ -------------------------------- coloca los obstáculos -------------- }
Repetir
A := A +1;
obstaculo(1, A);
hasta (a = 3);
obstaculo(1,7);
obstaculo(1, 8);
A := 1;
Repetir
A := A +1;
obstaculo(3, A);
hasta (a = 8);
{ ----------------------------Mueve los objetos -------------------------}
ABAJO (M1,8) ;
Repetir
M1:= Tomar; {-- toma un objeto --}
Arriba(M1,4);
Derecha(m1,2);
Arriba(M1,3);
Derecha(m1,2);
Dejar(m1); {-- deja el objeto tomado --}
Izquierda(M1,2);
Abajo(M1,3);
Izquierda(m1,2);
Estado(m1);
Abajo(M1,4);
Hasta( Numero(objeto)=0) ##repite hasta que no existan más objetos que llevar
Estado(m1);
FIN ;
Ejemplo de cómo queda el reporte del mapa al momento
de ejecutar las instrucciones anteriores.