Visual Algory

Documentación Visual Algory
0 de 75
Índice
No. Página
1. Iniciar con Visual Algory 2

1.1 ¿Qué es Visual Algory? 2
1.2 Historia de Visual Algory 2
1.3 Características y Limitaciones de Visual Algory 7
1.4 Funcionamiento General de Visual Algory 8
2. Comenzar a Trabajar con Visual Algory 9

2.1 ¿Qué se puede hacer con Visual Algory? 9
2.2 Pasos para Simular un Código en Visual Algory 9
2.3 Pasos para Simular un Archivo de Simulación en Visual Algory 9
3. Elementos de la Interfase 10
3.1 Barra de Menús 10
3.2 Barra de Herramientas 13
3.3 Ventana de Análisis 14
3.3.1 Análisis Léxico 14
3.3.2 Análisis Sintáctico 34
3.3.3 Análisis Semántico 48
3.4 Ventana de Errores 50
3.5 Estatus Bar 53
3.6 Código 54
3.7 Simulación 62
4. Mensajes de Error y Recuperación 65

4.1 Mensajes de Error 65
5. Glosario 71
1 de 75
Iniciar con Visual Algory

¿Qué es Visual Algory?
Es un Compilador de Código Algory que permite simular dicho código a través de la generación de
un Código Intermedio, este Compilador tiene un fin estrictamente educativo, ya que muestra
detenidamente los pasos que realiza un compilador para ejecutar una aplicación.
Historia de Visual Algory
Algory tiene sus inicios en la materia de Diseño Estructurado de Algoritmos de la carrera de

Ingeniería en Sistemas Computacionales del Instituto Tecnológico de la Laguna, este Algory
operaba en modo consola y fue realizado por la Ing. Martha Vallejo Moreno cuya última fecha de
actualización es del 10 de diciembre de 1998. A principios de enero de 2006 Gerardo Emilio Veloz
Flores recién egresado de la carrera de Ingeniería en Sistemas Computacionales del mismo
instituto, realizó una Gramática semejante a la de Algory para reconocer ese mismo código,
finalmente realizó Visual Algory en un periodo de 30 días; basándose en compiladores previamente
realizados para las materias de Programación de Sistemas I y II. Para el reconocimiento del Código
Algory utilizó E-Syntax un programa generador de Código para Análisis Sintáctico, lo cual facilitó el
trabajo de generación de Código Intermedio.
Algory:
2 de 75
Referencia del Algory.h
Primera Versión:
/*Algory.h
Archivo de macros para la materia de Diseño Estructurado de Algoritmos
de la carrera de Ing. En Sistemas Computacionales
Fecha de última actualización 10 de diciembre de 1998
Ing. Martha Vallejo Moreno
*/
/* Archivos de cabecera */
#include <stdio.h>
#include <conio.h>
#include <math.h>
#include <string.h>
#include <math.h>
#define INICIO_ALGORITMO void main(){

#define FIN_ALGORITMO }
#define MIENTRAS while(
#define FIN_MIENTRAS }
#define REPETIR do{
#define HASTA_QUE }while(!(
#define FIN_REPETIR ));
#define DESDE for(
#define HASTA ;!(
#define INCREMENTANDO );++
#define DECREMENTANDO );--
#define HACER ){
#define FIN_DESDE }
#define SI if(
#define ENTONCES ){
#define SINO } else {
#define FIN_SI }
#define SEGUN_SEA switch (
#define ES case
#define O_ES :case
#define INICIO_ES :
#define FIN_ES break;
#define NO_ES_NINGUNO default:
#define FIN_SEGUN }
#define ENTERO int
#define FIN_ENTERO ;
#define REAL float
#define FIN_REAL ;
#define CARACTER char
#define FIN_CARACTER ;
#define CADENA char
#define FIN_CADENA [80];
#define INICIA_CADENA char*
#define FIN_INICIA_CADENA ;
#define ASIGNA_CADENA(cad1, cad2) strcpy(cad1, cad2);
#define IGUAL_CADENA(cad1, cad2) !strcmp(cad1, cad2)
#define MAYOR_CADENA(cad1, cad2) strcmp(cad1, cad2) > 0 ? 1 : 0
#define MENOR_CADENA(cad1, cad2) strcmp(cad1, cad2) < 0 ? 1 : 0
#define LEER_ENTERO(a) scanf("%d",&a);
#define LEER_REAL(a) scanf("%f",&a);
#define LEER_CARACTER(a) a = getch();
#define LEER_CARACTER_ECO(a) a= getche();
#define LEER_CADENA(a) scanf("%s",a);
#define ESCRIBIR_ENTERO(a) printf("%d",(a));
#define ESCRIBIR_ENTERO_LN(a) printf("%d\n",(a));
#define ESCRIBIR_REAL(a) printf("%0.4f",(a));
#define ESCRIBIR_REAL_LN(a) printf("%0.4f\n",(a));
#define ESCRIBIR_CARACTER(a) putchar(a);
#define ESCRIBIR_CARACTER_LN(a) printf("%c\n",(a));
#define ESCRIBIR_CADENA(a) printf("%s",(a));
#define ESCRIBIR_CADENA_LN(a) printf("%s\n",(a));
3 de 75
#define SALTAR_LINEA putchar('\n');

#define POSICIONAR_CURSOR(a,b) gotoxy(a,b);
#define LIMPIAR_PANTALLA clrscr();
#define PAUSA gotoxy(5,24); \
printf ("Para continuar presiona una tecla"); \
getch();
#define SONIDO printf("\a\a\a\a\a\a");
#define INTENSIDAD_BAJA lowvideo();
#define INTENSIDAD_ALTA highvideo();
#define INTENSIDAD_NORMAL normvideo();
#define MODULO %
#define POTENCIA(b,e) pow(b,e)
#define RAIZ_CUA(b) sqrt(b)
#define IGUAL ==
#define DIFERENTE !=
#define NOT !
#define AND &&
#define OR ||
#define INCREMENTAR(a) ++a;
#define DECREMENTAR(a) --a;
#define CONSTANTE_ENTERO const int
#define CONSTANTE_REAL const float
#define CONSTANTE_CARACTER const char
#define CONSTANTE_CADENA const char*
#define FIN_CONSTANTE ;
#define TAMANO_ARREGLO enum tamano {
#define FIN_TAMANO };
#define REF_A &
#define REF_P *
#define PROCEDIMIENTO void
#define INICIO_PROCEDIMIENTO {
#define FIN_PROCEDIMIENTO }
#define SENO(a) (float)(sin((double)(M_PI*a)/180));
#define COSENO(a) (float)(cos((double)(M_PI*a)/180));
#define TANGENTE(a) (float)(tan((double)(M_PI*a)/180));
#define COTANGENTE(a) (float)(1/(tan((double)(M_PI*a)/180)));
#define SECANTE(a) (float)(1/cos((double)(M_PI*a)/180));
#define COSECANTE(a) (float)(1/sin((double)(M_PI*a)/180));
#define ARCOSENO(a) (float)(180*asin((double)a))/M_PI;
#define ARCOCOSENO(a) (float)(180*acos((double)a))/M_PI;
#define ARCOTAN(a) (float)(180*atan((double)a))/M_PI;
#define ARCOCOTAN(a) (float)(180*atan((double)(1/a)))/M_PI;
#define ARCOSEC(a) (float)(180*acos((double)(1/a)))/M_PI;
#define ARCOCOSEC(a) (float)(180*asin((double)(1/a)))/M_PI;
Segunda Versión:
/*Algory2.h
Archivo de macros para la materia de Computación II
Fecha de penúltima actualización 10 de diciembre de 1998 por Ing. Martha Vallejo Moreno
Fecha de última actualización 03 de Febrero de 2003 por Gerardo Emilio Veloz Flores
*/
/* Archivos de cabecera */
#include <stdio.h>
#include <conio.h>
#include <math.h>
#include <string.h>
#include <math.h>
/*#include <cruces.h>*/
/*#include <marcos.h>*/
/*#include <linea.h>*/
#define INICIO_ALGORITMO void main(){

#define FIN_ALGORITMO }
#define MIENTRAS while(
#define FIN_MIENTRAS }
#define REPETIR do{
#define HASTA_QUE }while(!(
#define FIN_REPETIR ));
4 de 75
#define DESDE for(

#define HASTA ;!(
#define INCREMENTANDO );++
#define DECREMENTANDO );--
#define HACER ){
#define FIN_DESDE }
#define SI if(
#define ENTONCES ){
#define SINO } else {
#define FIN_SI }
#define SEGUN_SEA switch (
#define ES case
#define O_ES :case
#define INICIO_ES :
#define FIN_ES break;
#define NO_ES_NINGUNO default:
#define FIN_SEGUN }
#define ENTERO int
#define FIN_ENTERO ;
#define REAL float
#define FIN_REAL ;
#define CARACTER char
#define FIN_CARACTER ;
#define CADENA char
#define FIN_CADENA [80];
#define INICIA_CADENA char*
#define FIN_INICIA_CADENA ;
#define ASIGNA_CADENA(cad1, cad2) strcpy(cad1, cad2);
#define IGUAL_CADENA(cad1, cad2) !strcmp(cad1, cad2)
#define MAYOR_CADENA(cad1, cad2) strcmp(cad1, cad2) > 0 ? 1 : 0
#define MENOR_CADENA(cad1, cad2) strcmp(cad1, cad2) < 0 ? 1 : 0
#define LEER_ENTERO(a) scanf("%d",&a);
#define LEER_REAL(a) scanf("%f",&a);
#define LEER_CARACTER(a) a = getch();
#define LEER_CARACTER_ECO(a) a= getche();
#define LEER_CADENA(a) scanf("%s",a);
#define ESCRIBIR_ENTERO(a) printf("%d",(a));
#define ESCRIBIR_ENTERO_LN(a) printf("%d\n",(a));
#define ESCRIBIR_REAL(a) printf("%0.4f",(a));
#define ESCRIBIR_REAL_LN(a) printf("%0.4f\n",(a));
#define ESCRIBIR_CARACTER(a) putchar(a);
#define ESCRIBIR_CARACTER_LN(a) printf("%c\n",(a));
#define ESCRIBIR_CADENA(a) printf("%s",(a));
#define ESCRIBIR_CADENA_LN(a) printf("%s\n",(a));
#define SALTAR_LINEA putchar('\n');
#define POSICIONAR_CURSOR(a,b) gotoxy(a,b);
#define LIMPIAR_PANTALLA clrscr();
#define PAUSA gotoxy(5,24); \
printf ("(P.V.C.)Presiona una tecla para continuar"); \
getch();
#define SONIDO printf("\a\a\a\a\a\a");
#define INTENSIDAD_BAJA lowvideo();
#define INTENSIDAD_ALTA highvideo();
#define INTENSIDAD_NORMAL normvideo();
#define MODULO %
#define POTENCIA(b,e) pow(b,e)
#define RAIZ_CUA(b) sqrt(b)
#define IGUAL ==
#define DIFERENTE !=
#define NOT !
#define AND &&
#define OR ||
#define INCREMENTAR(a) ++a;
#define DECREMENTAR(a) --a;
#define CONSTANTE_ENTERO const int
#define CONSTANTE_REAL const float
#define CONSTANTE_CARACTER const char
#define CONSTANTE_CADENA const char*
#define FIN_CONSTANTE ;
#define TAMANO_ARREGLO enum tamano {
5 de 75
#define FIN_TAMANO };
#define REF_A &
#define REF_P *
#define PROCEDIMIENTO void
#define INICIO_PROCEDIMIENTO {
#define FIN_PROCEDIMIENTO }
#define SENO(a) (float)(sin((double)(M_PI*a)/180));
#define COSENO(a) (float)(cos((double)(M_PI*a)/180));
#define TANGENTE(a) (float)(tan((double)(M_PI*a)/180));
#define COTANGENTE(a) (float)(1/(tan((double)(M_PI*a)/180)));
#define SECANTE(a) (float)(1/cos((double)(M_PI*a)/180));
#define COSECANTE(a) (float)(1/sin((double)(M_PI*a)/180));
#define ARCOSENO(a) (float)(180*asin((double)a))/M_PI;
#define ARCOCOSENO(a) (float)(180*acos((double)a))/M_PI;
#define ARCOTAN(a) (float)(180*atan((double)a))/M_PI;
#define ARCOCOTAN(a) (float)(180*atan((double)(1/a)))/M_PI;
#define ARCOSEC(a) (float)(180*acos((double)(1/a)))/M_PI;
#define ARCOCOSEC(a) (float)(180*asin((double)(1/a)))/M_PI;
#define CRUZ_SIMPLE(a,b) gotoxy(a,b); \

putchar (197); \
gotoxy(a,b);
#define CRUZ_DOBLE(a,b) gotoxy(a,b); \

putchar (206); \
gotoxy(a,b);
#define LINEA_SIMPLE_H(a,b,c,d) gotoxy(a,b); putchar(195); for(i=a;i<c-1;i++) putchar (196); putchar(180);
#define LINEA_DOBLE_H(a,b,c,d) gotoxy(a,b); putchar(204); for(i=a+1;i<c;i++) putchar (205); putchar(185);
#define LINEA_SIMPLE_V(a,b,c,d) gotoxy(a,b); for(i=b;i<d;i++) {gotoxy(a,i); putchar (179);} gotoxy(a,i); putchar(193);

gotoxy(a,b); putchar(194);
#define LINEA_DOBLE_V(a,b,c,d) gotoxy(a,b); for(i=b;i<d;i++) {gotoxy(a,i); putchar (186);} gotoxy(a,i); putchar(202);

gotoxy(a,b); putchar(203);
#define CUADRO_SIMPLE(a,b,c,d) gotoxy(a,b); putchar(218); gotoxy(c,d); putchar(217); gotoxy(c,b); putchar(191);

gotoxy(a,d); putchar(192); for(i=a+1;i<c;i++) {putchar(196);} gotoxy(a+1,b); for(i=a+1;i<c;i++) {putchar(196);} gotoxy(c,b);
for(i=b+1;i<d;i++) { gotoxy(c,i); putchar(179);} gotoxy(a,b); for(i=b+1;i<d;i++) { gotoxy(a,i); putchar(179);};
#define CUADRO_DOBLE(a,b,c,d) gotoxy(a,b); putchar(201); gotoxy(c,d); putchar(188); gotoxy(c,b); putchar(187);

gotoxy(a,d); putchar(200); for(i=a+1;i<c;i++) {putchar(205);} gotoxy(a+1,b); for(i=a+1;i<c;i++) {putchar(205);} gotoxy(c,b);
for(i=b+1;i<d;i++) { gotoxy(c,i); putchar(186);} gotoxy(a,b); for(i=b+1;i<d;i++) { gotoxy(a,i); putchar(186);};
6 de 75
Iniciar con Visual Algory
Características y Limitaciones de Visual Algory
Visual Algory cuenta con la siguiente Interfase Gráfica:
La Interfase Gráfica de Visual Algory esta compuesta por los siguientes Elementos:
1. Barra de Menús
2. Barra de Herramientas
3. Ventana de Análisis
4. Ventana de Errores
5. Estatus Bar
6. Código
7. Simulación
Limitaciones de Visual Algory
Función Límite Máximo

Token Totales a Reconocer 1000
Derivaciones a la Izquierda 1000
Tipos de Variables 3
Archivos de Código Simultáneos 1
7 de 75
Funcionamiento General de Visual Algory
Visual Algory opera de la siguiente forma:
Compilación
Código Fuente (*.COD)
Análsis Léxico
Análisis Sintáctico
Análisis Semántico
Obtención de la Tabla de Símbolos Tabla de Símbolos (*.TBS)
Obtención del Código Intermedio Código Intermedio (*.CIN)
Simulación
Simulación del Código Intermedio
Ejecución
Descripción
Visual Algory trabaja sobre un Archivo de Código Fuente (.COD), al cual se le realiza un Análisis
Léxico para determinar que Tokens están dentro de él, si no posee errores pasa al Análisis
Sintáctico el cual verifica que los Tokens cumplan con la Gramática de Visual Algory, si no posee
errores pasa al Análisis Semántico para identificar las Variables utilizadas dentro del Código
Fuente, los tipos de las mismas y correspondencias en declaraciones; si no posee errores se le
genera su Archivo de Tabla de Símbolos (.TBS), y su Archivo de Código Intermedio (.CIN), los
cuales serán utilizados para la Simulación, de manera que ésta se Ejecute dentro de Visual Algory.
8 de 75
Comenzar a Trabajar con Visual Algory
¿Qué se puede hacer con Visual Algory?
Visual Algory permite Simular un Código Fuente el cual es sometido a una serie de Análisis para
determinar si es correcto. Éstos son mostrados para identificar cada una de las Fases de
Compilación, los Análisis realizados al Código Fuente son:
1. Análisis Léxico
2. Análisis Sintáctico
3. Análisis Semántico
Pasos para Simular un Código en Visual Algory
1. Cree un Nuevo Archivo de Código dando clic en el botón Nuevo .

2. Introduzca un Código en el SynEdit del Nuevo Archivo.
3. De clic en el botón Compilar .

4. Si no existen errores, seleccione la pestaña Simulación.
5. De clic en el botón Simular .

6. Vea la Simulación en el SynEdit de Ejecución.
Pasos para Simular un Archivo de Simulación en Visual Algory
1. Abra un Archivo de Simulación dando clic en el botón Abrir y seleccione la Opción

Simulación.
2. De clic en el botón Simular .

3. Vea la Simulación en el SynEdit de Ejecución.
9 de 75
Elementos de la Interfase
Barra de Menús
El Aspecto de la Barra de Menús es el siguiente:
Esta dividida en 4 Menús los cuales son:
1. Menú Archivo
Nuevo: Crea un Nuevo Archivo de Código.
Abrir: Abre un Archivo de Código o una Simulación existente

para poder editarlo y simularlo.
Guardar: Guarda el Archivo de Código Activo, con su

Nombre y Ubicación Actual.
Guardar como: Permite Guardar el Archivo de Código Activo

con otro Nombre y Ubicación.
Vista Previa: Muestra una Vista Previa del Archivo de

Código Activo. Para seleccionar las Opciones de Impresión
haga clic en Propiedades de Impresión, en el Menú Archivo.
Imprimir: Imprime el Archivo de Código Activo.
Propiedades de Impresión: Muestra el Diálogo "Configurar Impresión"; donde se puede

especificar las Características de Impresión.
Cerrar: Cierra el Archivo de Código Activo.
Proyecto: Permite Compilar o Simular el Archivo de Código Activo.
Salir: Cierra la Aplicación.
10 de 75
2. Menú Edición
Cortar: Quita la Selección del Archivo de Código Activo y la coloca

en el Portapapeles
Copiar: Copia la Selección del Archivo de Código Activo al

Portapapeles.
Pegar: Inserta el Contenido del Portapapeles en el Punto de

Inserción del Archivo de Código Activo y Reemplaza la Selección
Actual.
Eliminar: Elimina la selección del Archivo de Código Activo.
Buscar: Busca el Texto Especificado en el Diálogo Buscar dentro

del Archivo de Código Activo.
Reemplazar: Busca y Reemplaza el Texto Especificado en el

Diálogo Reemplazar dentro del Archivo de Código Activo.
Ir a: Muestra la selección en la Línea especificada.
Deshacer: Invierte o elimina la Última entrada, que haya escrito en el Archivo de Código Activo.
Rehacer: Invierte la Acción del Comando Deshacer. Es decir Rehace la Última Acción Deshecha.
Seleccionar todo: Selecciona todo el Texto del Archivo de Código Activo.
3. Menú Ver
Ventana de Análisis: Muestra u Oculta la Ventana de

Análisis de Visual Algory.
Ventana de Errores: Muestra u Oculta la Ventana de Errores

de Visual Algory.
Barra de Herramientas Estándar: Muestra u Oculta la Barra

de Herramientas Estándar de Visual Algory.
Modo: Especifica el Modo de Visualización (Profesional o Estudiantil).
Opciones de Reconocimiento: Muestra el Diálogo Opciones de Reconocimiento.
11 de 75
4. Menú Ayuda
Acerca de: Muestra el Diálogo Acerca de Visual Algory; donde

puede encontrar Información del Copyright ©.
Documentación: Muestra la Documentación referente a Visual

Algory en formato PDF.
¿Qué es Esto?: Activa la Ayuda Sensible al Contexto.
Ayuda HLP: Muestra el Archivo de Ayuda de Visual Algory en

Formato HLP.
Ayuda CHM: Muestra el Archivo de Ayuda de Visual Algory en Formato CHM.
12 de 75
Barra de Herramientas
La Barra de Herramientas de Visual Algory esta constituida por la siguiente Barra de Herramientas:
Barra de Herramientas Estándar
Esta constituida por los siguientes Botones
Nuevo
Abrir
Guardar
Vista Previa
Imprimir
Cerrar
Cortar
Copiar
Pegar
Buscar
Reemplazar
Deshacer
Rehacer
Compilar
13 de 75
Ventana de Análisis
El Aspecto de la Ventana de Análisis es el siguiente:
Se encuentra a la Izquierda de la Interfase de Visual Algory (aunque es posible modificar su

ubicación), esta constituida por 3 Elementos:
1.- Análisis Léxico
Esta Pestaña Muestra el Análisis Léxico realizado al

Archivo de Código Activo. Se reconocen 22 tipos de
tokens que fueron simplificados a tan solo 13 tipos:
Original Final
Delim * -
Enter -
Coment -
opRel1 oprel
opRel2 * oprel
opAsig2* Lexema
opAsig1 Lexema
opLog Lexema
opInc Lexema
opDec Lexema
char cadena
opArit Lexema
separ Lexema
cadena cadena
id * id
num1 * flotante
num3 * flotante
num2 * flotante
num0 numero
num4 * numero
termIns Lexema
error -
14 de 75
* Indica Token con Retraer.
Las Expresiones Regulares que corresponden a cada token se muestran a continuación:
1. Delimitador (Delim)
2. Enter (enter)
3. Comentarios (Comentario)
4. Operadores Relacionales (opRel1 y opRel2)
15 de 75
5. Operadores de Asignación (opAsig2 y opAsig1)
6. Operadores Lógicos (opLog)
7. Operador Incremental (opinc)
8. Operador Decremental (opDec)
16 de 75
9. Carácter (caracter)
10. Operadores Aritméticos (opArit)
11. Separador (separador)
12. Cadena (cadena)
17 de 75
13. Identificador (id)
14. Números (num1, num3, num2, num0 y num4)
18 de 75
19 de 75
15. Terminador de Instrucción (termIns)
16. Error (error)
20 de 75
Implementación
La implementación del Análisis Léxico, esta definida en los siguientes Módulos:
Lexico.h
//---------------------------------------------------------------------------
#ifndef LexicoH
#define LexicoH
//---------------------------------------------------------------------------
#include <vcl/grids.hpp>
#include "Unit1.h"
//---------------------------------------
// UNIDAD LEXICO.H
//---------------------------------------
const int TOKREC = 22;
const int MAXTOKENS = 1000;
const int ANCHOTOKEN = 20;
const int ANCHOLEXEMA = 255;
const int ANCHOPALABRA = 10;
const int NOPALRES = 12;
char asNomAuto[TOKREC]
[ANCHOTOKEN]={"delim","enter","coment","opRel1","opRel2","opAsig2","opAsig1","opLog","opinc","opDec","char","opArit","
separado","cadena","id","num1","num3","num2","num0","num4","termIns","error"};
//--------------------------
class Automata
{
int iEdoAct;
char *psTexto;
char NextChar(int &iI) { return psTexto[iI++]; }
public :
int iReconoce(char *, int &, int &, int);
};
//---------------------------
//---------------------------
class Lexico
{
int asRenglon[MAXTOKENS];
int Error;
int iI,iIniToken,iNoTokens,iNoRenglon,iNoError;
char asTokens[MAXTOKENS][ANCHOTOKEN];
char asLexemas[MAXTOKENS][ANCHOLEXEMA];
char asError[MAXTOKENS][ANCHOLEXEMA];
char sLexema[255];
int DirEnter[MAXTOKENS/2];
Automata oAFD;
public :
void Analiza(char *);
void Inicia(void);
void Lexema(char *);
int EsId();
void Mostrar(TStringGrid *A,TPanel *P);
char* RetToken(int);
char* RetLexema(int i){return asLexemas[i];};
void Anade(char *);
int RetError(){return Error;};
char* RetDefError(int i){return asError[i];};
int RetRenError(int i){return asRenglon[i];};
int RetNoErro(){return iNoError;};
int RetiNoTokens(){return iNoTokens;};
int RetDirEnter(int);
};
//---------------------------------------------------------------------------
#endif
21 de 75
Lexico.cpp
//---------------------------------------------------------------------------
#pragma hdrstop
#include "Lexico.h"
#include "Unit1.h"
//---------------------------------------------------------------------------
//---------------------------------------
// UNIDAD LEXICO.CPP
//---------------------------------------
//---------------------------------------
void Lexico::Lexema(char *pTexto)
{
int iL,iM=0;
for(iL=iIniToken;iL<iI;iL++,iM++)
sLexema[iM]=pTexto[iL];
sLexema[iM]='\0';
}
//---------------------------------------
void Lexico::Inicia(void)
{
iIniToken=iI=iNoTokens=iNoRenglon=iNoError=0;
for(int i=0;i<MAXTOKENS;i++)
{
asRenglon[i]=-1;
strcpy(asError[i],"");
}
for(int i=0;i<MAXTOKENS/2;i++)
{
DirEnter[i]=-1;
}
Error=false;
}
//---------------------------------------
void Lexico::Analiza(char *pTexto)
{
int iNoAuto,iRec;
while(iI<strlen(pTexto))
{
for(iNoAuto=0,iRec=FALSE;iNoAuto<TOKREC && !iRec;)
if (oAFD.iReconoce(pTexto,iIniToken,iI,iNoAuto))
iRec=TRUE;
else
iNoAuto++;
if (iRec)
{
Lexema(pTexto);
switch(iNoAuto)
{
//-------------- Automata delim--------------
case 0 : //strcpy(asTokens[iNoTokens],"delim");
break;
//-------------- Automata enter--------------
case 1 : //strcpy(asTokens[iNoTokens],"enter");
DirEnter[iNoRenglon]=iNoTokens-1;
iNoRenglon++;
break;
//-------------- Automata coment--------------
case 2 : //strcpy(asTokens[iNoTokens],"coment");
break;
//-------------- Automata opRel1--------------
case 3 : strcpy(asTokens[iNoTokens],"oprel");
break;
//-------------- Automata opRel2--------------
case 4 : strcpy(asTokens[iNoTokens],"oprel");
break;
//-------------- Automata opAsig2--------------
22 de 75
case 5 : //strcpy(asTokens[iNoTokens],"opAsig2");
strcpy(asTokens[iNoTokens],sLexema);
break;
//-------------- Automata opAsig1--------------
case 6 : //strcpy(asTokens[iNoTokens],"opAsig1");
break;
//-------------- Automata opLog--------------
case 7 : //strcpy(asTokens[iNoTokens],"opLog");
break;
//-------------- Automata opinc--------------
case 8 : //strcpy(asTokens[iNoTokens],"opinc");
break;
//-------------- Automata opDec--------------
case 9 : //strcpy(asTokens[iNoTokens],"opDec");
break;
//-------------- Automata char--------------
case 10 : strcpy(asTokens[iNoTokens],"cadena");
break;
//-------------- Automata opArit--------------
case 11 : //strcpy(asTokens[iNoTokens],"opArit");
break;
//-------------- Automata separado--------------
case 12 : //strcpy(asTokens[iNoTokens],"separado");
break;
//-------------- Automata cadena--------------
case 13 : strcpy(asTokens[iNoTokens],"cadena");
break;
//-------------- Automata id--------------
case 14 : if(EsId())
{
strcpy(asTokens[iNoTokens],"id");
}
else
{
}
break;
//-------------- Automata num1--------------
case 15 : strcpy(asTokens[iNoTokens],"flotante");
break;
//-------------- Automata num3--------------
break;
//-------------- Automata num2--------------
break;
//-------------- Automata num0--------------
case 18 : strcpy(asTokens[iNoTokens],"numero");
break;
//-------------- Automata num4--------------
case 19 : strcpy(asTokens[iNoTokens],"numero");
break;
//-------------- Automata termIns--------------
case 20 : //strcpy(asTokens[iNoTokens],"termIns");
break;
//-------------- Automata error--------------
case 21 : //strcpy(asTokens[iNoTokens],"error");
Error = true;
break;
}
if(iNoAuto!=0&&iNoAuto!=1&&iNoAuto!=2&&iNoAuto!=21)
{
strcpy(asLexemas[iNoTokens++],sLexema);
23 de 75
}
if(iNoAuto==21)
{
strcpy(asError[iNoError],sLexema);
asRenglon[iNoError]=iNoRenglon;
iNoError++;
}
}
else
iI++;
iIniToken=iI;
}
}
//---------------------------------------
int Automata::iReconoce(char *pTexto,int &iIniToken,int &iI,int iNoAuto)
{
char c;
psTexto=pTexto;
switch(iNoAuto)
{
//-------------- Automata delim--------------
case 0 : iEdoAct=0;
break;
//-------------- Automata enter--------------
case 1 : iEdoAct=3;
break;
//-------------- Automata coment--------------
case 2 : iEdoAct=5;
break;
//-------------- Automata opRel1--------------
case 3 : iEdoAct=10;
break;
//-------------- Automata opRel2--------------
break;
//-------------- Automata opAsig2--------------
break;
//-------------- Automata opAsig1--------------
break;
//-------------- Automata opLog--------------
break;
//-------------- Automata opinc--------------
break;
//-------------- Automata opDec--------------
break;
//-------------- Automata char--------------
break;
//-------------- Automata opArit--------------
break;
break;
//-------------- Automata cadena--------------
break;
//-------------- Automata id--------------
break;
//-------------- Automata num1--------------
break;
//-------------- Automata num3--------------
24 de 75
break;
//-------------- Automata num2--------------
break;
//-------------- Automata num0--------------
break;
//-------------- Automata num4--------------
break;
break;
//-------------- Automata error--------------
break;
}
while(iI<=strlen(psTexto))
switch(iEdoAct)
{
//-------------- Automata delim--------------
case 0 : c=NextChar(iI);
if (strchr(" \t\r",c) && c) iEdoAct=1; else
{ iI=iIniToken;
return FALSE; }
break;
if (strchr(" \t\r",c) && c) iEdoAct=1; else
if (strchr("!\"#$%&\'()*+,-./0123456789:;<=>?
@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_àbcdefghijklmnopqrstuvwxyz{|}~€ ‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ
¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿\n\f",c)) iEdoAct=2; else
{ iI=iIniToken;
return FALSE; }
break;
case 2 : iI--;
return TRUE;
break;
//-------------- Automata enter--------------
if (strchr("\n",c) && c) iEdoAct=4; else
{ iI=iIniToken;
return FALSE; }
break;
case 4 : return TRUE;
break;
//-------------- Automata coment--------------
if (strchr("/",c) && c) iEdoAct=6; else
{ iI=iIniToken;
return FALSE; }
break;
if (strchr("*",c) && c) iEdoAct=7; else
{ iI=iIniToken;
return FALSE; }
break;
if (strchr(" !\"#$%&\'()+,-.0123456789:;<=>?
@áéíóúÁÉÍÓÚABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_àbcdefghijklmnopqrstuvwxyzñÑ{|}~ €‚ƒ„…†‡ˆ
‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿\n\t\r\f",c) && c) iEdoAct=7; else
{ iI=iIniToken;
return FALSE; }
break;
25 de 75
if (strchr(" !\"#$%&\'()+,-.0123456789:;<=>?
@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_àbcdefghijklmnopqrstuvwxyzñÑ{|}~ €‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—
˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿\n\t\r\f",c) && c) iEdoAct=7; else
{ iI=iIniToken;
return FALSE; }
break;
break;
//-------------- Automata opRel1--------------
if (strchr("!<>",c) && c) iEdoAct=11; else
if (strchr("=",c) && c) iEdoAct=11; else
{ iI=iIniToken;
return FALSE; }
break;
{ iI=iIniToken;
return FALSE; }
break;
break;
//-------------- Automata opRel2--------------
if (strchr("<>",c) && c) iEdoAct=14; else
{ iI=iIniToken;
return FALSE; }
break;
if (strchr("<>",c)) iEdoAct=15; else
if (strchr(" !\"#$%&\'()*+,-./0123456789:;?
¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿\n\t\r\f",c)) iEdoAct=15; else
{ iI=iIniToken;
return FALSE; }
break;
case 15 : iI--;
return TRUE;
break;
//-------------- Automata opAsig2--------------
{ iI=iIniToken;
return FALSE; }
break;
if (strchr(" !\"#$%&\'()*+,-./0123456789:;<>?
{ iI=iIniToken;
return FALSE; }
break;
case 18 : iI--;
return TRUE;
break;
//-------------- Automata opAsig1--------------
if (strchr("+",c) && c) iEdoAct=20; else
if (strchr("-",c) && c) iEdoAct=20; else
if (strchr("%",c) && c) iEdoAct=20; else
{ iI=iIniToken;
return FALSE; }
break;
{ iI=iIniToken;
return FALSE; }
break;
26 de 75

break;
//-------------- Automata opLog--------------
if (strchr("!",c) && c) iEdoAct=23; else
if (strchr("&",c) && c) iEdoAct=24; else
if (strchr("|",c) && c) iEdoAct=25; else
{ iI=iIniToken;
return FALSE; }
break;
break;
if (strchr("&",c) && c) iEdoAct=23; else
{ iI=iIniToken;
return FALSE; }
break;
if (strchr("|",c) && c) iEdoAct=23; else
{ iI=iIniToken;
return FALSE; }
break;
//-------------- Automata opinc--------------
{ iI=iIniToken;
return FALSE; }
break;
{ iI=iIniToken;
return FALSE; }
break;
break;
//-------------- Automata opDec--------------
{ iI=iIniToken;
return FALSE; }
break;
{ iI=iIniToken;
return FALSE; }
break;
break;
//-------------- Automata char--------------
if (strchr("\'",c) && c) iEdoAct=33; else
{ iI=iIniToken;
return FALSE; }
break;
if (strchr("\\",c) && c) iEdoAct=35; else
if (strchr("Oo",c) && c) iEdoAct=34; else
if (strchr("01234567",c) && c) iEdoAct=34; else
if (strchr("Xx",c) && c) iEdoAct=34; else
if (strchr("89ABCDEFabcde",c) && c) iEdoAct=34; else
if (strchr("nrt",c) && c) iEdoAct=34; else
if (strchr(" !\"#$%&()*+,-./:;<=>?@áéíóúÁÉÍÓÚGHIJKLMNPQRSTUVWYZ[]^_`ghijklmpqsuvwyz{|}~ €‚ƒ„…†‡ˆ
‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿",c) && c) iEdoAct=34; else
if (strchr("f",c) && c) iEdoAct=34; else
{ iI=iIniToken;
return FALSE; }
break;
27 de 75
{ iI=iIniToken;
return FALSE; }
break;
if (strchr("Oo",c) && c) iEdoAct=37; else
if (strchr("Xx",c) && c) iEdoAct=38; else
if (strchr("nrt",c) && c) iEdoAct=34; else
{ iI=iIniToken;
return FALSE; }
break;
break;
{ iI=iIniToken;
return FALSE; }
break;
{ iI=iIniToken;
return FALSE; }
break;
{ iI=iIniToken;
return FALSE; }
break;
{ iI=iIniToken;
return FALSE; }
break;
//-------------- Automata opArit--------------
if (strchr("%*+-^/\\",c) && c) iEdoAct=42; else
{ iI=iIniToken;
return FALSE; }
break;
break;
if (strchr("(),[]{}",c) && c) iEdoAct=44; else
{ iI=iIniToken;
return FALSE; }
break;
break;
//-------------- Automata cadena--------------
if (strchr("\"",c) && c) iEdoAct=46; else
{ iI=iIniToken;
return FALSE; }
break;
if (strchr("\"",c) && c) iEdoAct=47; else
if (strchr(" !#$%&\'()*+,-./0123456789:;<=>?
@áéíóúÁÉÍÓÚABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_àbcdefghijklmnopqrstuvwxyzÑñ{|}~ €‚ƒ„…†‡ˆ
‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿\n\t\r\f",c) && c) iEdoAct=46; else
{ iI=iIniToken;
return FALSE; }
break;
break;
//-------------- Automata id--------------
28 de 75
if (strchr("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",c) && c) iEdoAct=49; else
{ iI=iIniToken;
return FALSE; }
break;
if (strchr("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",c) && c) iEdoAct=49; else
if (strchr("_",c) && c) iEdoAct=49; else
if (strchr(" !\"#$%&\'()*+,-./:;<=>?@[\\]^`{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³
´µ¶·¸¹º»¼½¾¿\n\t\r\f",c)) iEdoAct=50; else
{ iI=iIniToken;
return FALSE; }
break;
case 50 : iI--;
return TRUE;
break;
//-------------- Automata num1--------------
{ iI=iIniToken;
return FALSE; }
break;
if (strchr(".",c) && c) iEdoAct=53; else
if (strchr("Ee",c) && c) iEdoAct=54; else
{ iI=iIniToken;
return FALSE; }
break;
{ iI=iIniToken;
return FALSE; }
break;
{ iI=iIniToken;
return FALSE; }
break;
{ iI=iIniToken;
return FALSE; }
break;
if (strchr(".",c)) iEdoAct=58; else
if (strchr("Ee",c)) iEdoAct=58; else
if (strchr("+",c)) iEdoAct=58; else
if (strchr("-",c)) iEdoAct=58; else
if (strchr(" !\"#$%&\'()*,/:;<=>?@ABCDFGHIJKLMNOPQRSTUVWXYZ[\\]^_àbcdfghijklmnopqrstuvwxyz{|}~ €
‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿\n\t\r\f",c)) iEdoAct=58; else
{ iI=iIniToken;
return FALSE; }
break;
{ iI=iIniToken;
return FALSE; }
break;
case 58 : iI--;
return TRUE;
break;
//-------------- Automata num3--------------
29 de 75

{ iI=iIniToken;
return FALSE; }
break;
{ iI=iIniToken;
return FALSE; }
break;
{ iI=iIniToken;
return FALSE; }
break;
{ iI=iIniToken;
return FALSE; }
break;
{ iI=iIniToken;
return FALSE; }
break;
{ iI=iIniToken;
return FALSE; }
break;
if (strchr("Ee",c)) iEdoAct=67; else
if (strchr("+",c)) iEdoAct=67; else
if (strchr("-",c)) iEdoAct=67; else
if (strchr(" !\"#$%&\'()*,/:;<=>?@ABCDFGHIJKLMNOPQRSTUVWXYZ[\\]^_àbcdfghijklmnopqrstuvwxyz{|}~ €
‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿\n\t\r\f",c)) iEdoAct=67; else
{ iI=iIniToken;
return FALSE; }
break;
{ iI=iIniToken;
return FALSE; }
break;
case 67 : iI--;
return TRUE;
break;
//-------------- Automata num2--------------
{ iI=iIniToken;
return FALSE; }
break;
{ iI=iIniToken;
return FALSE; }
break;
if (strchr(" !\"#$%&\'()*+,-/:;<=>?
30 de 75
{ iI=iIniToken;
return FALSE; }
break;
case 71 : iI--;
return TRUE;
break;
//-------------- Automata num0--------------
{ iI=iIniToken;
return FALSE; }
break;
{ iI=iIniToken;
return FALSE; }
break;
break;
//-------------- Automata num4--------------
{ iI=iIniToken;
return FALSE; }
break;
if (strchr(" !\"#$%&\'()*+,-./:;<=>?
{ iI=iIniToken;
return FALSE; }
break;
case 77 : iI--;
return TRUE;
break;
if (strchr(";",c) && c) iEdoAct=79; else
{ iI=iIniToken;
return FALSE; }
break;
break;
//-------------- Automata error--------------
if (strchr(" !\"#$%&\'()*+,-./0123456789:;<=>?
¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿\n\t\r\f",c) && c) iEdoAct=81; else
{ iI=iIniToken;
return FALSE; }
break;
break;
}
switch(iEdoAct)
{
case 2 : // Autómata delim
case 15 : // Autómata opRel2
case 18 : // Autómata opAsig2
case 50 : // Autómata id
case 58 : // Autómata num1
--iI;
return TRUE;
}
return FALSE;
31 de 75
}
//---------------------------------------
void Lexico::Mostrar(TStringGrid *A,TPanel *P)
{
int i;
if(iNoTokens==0)
{
A->RowCount= 2;
}
else
{
A->RowCount= iNoTokens+1;
}
for(i=0;i<=iNoTokens;i++)
{
A->Cells[0][(i+1)]=asTokens[i];
A->Cells[1][(i+1)]=asLexemas[i];
}
if(A->Cells[0][1]!="")
{
if(iNoTokens>1)
{
P->Caption=AnsiString(iNoTokens)+ " Tokens Reconocidos";
}
else
{
P->Caption="Un Token Reconocido";
}
}
}
//---------------------------------------------------------------------------
int Lexico::EsId(void)
{
char asPalRes[NOPALRES]
[ANCHOPALABRA]={"caracter","desde","entero","escribir","fin","flotante","hacer","inicio","leer","mientras","si","sino"};
int Res;
for(int i=0;i<NOPALRES;i++)
{
if(strcmp(asPalRes[i],sLexema)==0)
{
return 0;
}
Res = 1;
}
return Res;
}//---------------------------------------------------------------------------
char* Lexico::RetToken(int ae)
{
return asTokens[ae];
}
//---------------------------------------------------------------------------
void Lexico::Anade(char *ptok)
{
strcpy(asTokens[iNoTokens],ptok);
strcpy(asLexemas[iNoTokens],ptok);
}
//---------------------------------------------------------------------------
int Lexico::RetDirEnter(int Tok)
{
if(Tok<=DirEnter[0])
{
return 1;
}
for(int i=0;i<iNoRenglon;i++)
{
if(Tok>=DirEnter[i]&&Tok<=DirEnter[i+1])
{
return i+2;
}
}
32 de 75
if(Tok>=DirEnter[iNoRenglon-1])
{
return iNoRenglon+1;
}
}
//---------------------------------------------------------------------------
#pragma package(smart_init)
33 de 75
2.- Análisis Sintáctico
Esta Pestaña Muestra el Análisis Sintáctico que se ha

realizado al Archivo de Código Activo. Para realizar este
Análisis se utiliza la siguiente Gramática:
{{Programa}} -> {{ListaVar}} {{BloqueProg}}

{{ListaVar}} -> entero {{ListaId}} {{ListaVar}} | flotante {{ListaId}} {{ListaVar}} | caracter {{ListaId}}
{{ListaVar}} | £
{{ListaId}} -> id {{R1}}
{{R1}} -> , {{ListaId}} | ;
{{BloqueProg}} -> inicio { {{ListaProp}} } fin
{{ListaProp}} -> {{PropSi}} {{ListaProp}} | {{PropMientras}} {{ListaProp}} | {{PropHacer}}
{{ListaProp}} | {{PropDesde}} {{ListaProp}} | {{PropAsig}} {{ListaProp}} | {{PropLeer}}
{{ListaProp}} | {{PropEscribir}} {{ListaProp}} | £
{{PropSi}} -> si ( {{Exp}} ) { {{ListaProp}} } {{R2}}
{{R2}} -> sino { {{ListaProp}} } | £
{{PropMientras}} -> mientras ( {{Exp}} ) { {{ListaProp}} }
{{PropHacer}} -> hacer { {{ListaProp}} } mientras ( {{Exp}} ) ;
{{PropDesde}} -> desde ( {{PropAsig}} {{Exp}} ; {{Exp}} ) { {{ListaProp}} }
{{PropAsig}} -> id = {{Exp}} ;
{{PropLeer}} -> leer ( id ) ;
{{PropEscribir}} -> escribir ( {{A1}} ) ;
{{A1}} -> id | cadena {{R3}}
{{R3}} -> , id | £
{{Exp}} -> {{E}} {{R4}}
{{E}} -> {{F}} {{E2}}
{{F}} -> ( {{Exp}} ) | id {{R5}} | ++ id | -- id | ! {{F}} | numero | flotante
{{R5}} -> -- | ++ | £
{{E2}} -> + {{F}} {{E2}} | - {{F}} {{E2}} | * {{F}} {{E2}} | / {{F}} {{E2}} | % {{F}} {{E2}} | ^ {{F}} {{E2}} | ||
{{F}} {{E2}} | && {{F}} {{E2}} | £
{{R4}} -> oprel {{E}} | £
34 de 75
Como la Gramática a utilizar posee Recursividad a la Izquierda, fue necesario el realizar ERI, FI,
Primeros, Siguientes y Tabla M para poder aplicar un Análisis Sintáctico.
Gramática sin Recursividad a la Izquierda:

{{ListaVar}} -> entero {{ListaId}} {{ListaVar}} | flotante {{ListaId}} {{ListaVar}} | caracter {{ListaId}} {{ListaVar}} | £
{{R1}} -> , {{ListaId}} | ;
{{ListaProp}} -> {{PropSi}} {{ListaProp}} | {{PropMientras}} {{ListaProp}} | {{PropHacer}} {{ListaProp}} | {{PropDesde}}
{{ListaProp}} | {{PropAsig}} {{ListaProp}} | {{PropLeer}} {{ListaProp}} | {{PropEscribir}} {{ListaProp}} | £
{{R2}} -> sino { {{ListaProp}} } | £
{{A1}} -> id | cadena {{R3}}
{{R3}} -> , id | £
{{Exp}} -> {{E}} {{R4}}
{{E}} -> {{F}} {{E2}}
{{R5}} -> -- | ++ | £
{{E2}} -> + {{F}} {{E2}} | - {{F}} {{E2}} | * {{F}} {{E2}} | / {{F}} {{E2}} | % {{F}} {{E2}} | ^ {{F}} {{E2}} | || {{F}} {{E2}} | && {{F}} {{E2}}
|£
{{R4}} -> oprel {{E}} | £
Gramática Factorizada a la Izquierda:

{{ListaVar}} -> entero {{ListaId}} {{ListaVar}} | flotante {{ListaId}} {{ListaVar}} | caracter {{ListaId}} {{ListaVar}} | £
{{R1}} -> , {{ListaId}} | ;
{{ListaProp}} -> {{PropSi}} {{ListaProp}} | {{PropMientras}} {{ListaProp}} | {{PropHacer}} {{ListaProp}} | {{PropDesde}}
{{ListaProp}} | {{PropAsig}} {{ListaProp}} | {{PropLeer}} {{ListaProp}} | {{PropEscribir}} {{ListaProp}} | £
{{R2}} -> sino { {{ListaProp}} } | £
{{A1}} -> id | cadena {{R3}}
{{R3}} -> , id | £
{{Exp}} -> {{E}} {{R4}}
{{E}} -> {{F}} {{E2}}
{{R5}} -> -- | ++ | £
{{E2}} -> + {{F}} {{E2}} | - {{F}} {{E2}} | * {{F}} {{E2}} | / {{F}} {{E2}} | % {{F}} {{E2}} | ^ {{F}} {{E2}} | || {{F}} {{E2}} | && {{F}} {{E2}}
|£
{{R4}} -> oprel {{E}} | £
35 de 75
Primeros de la Gramática Factorizada a la Izquierda:
Prim( {{Programa}} )= £ entero flotante caracter inicio

Prim( {{ListaVar}} )= £ entero flotante caracter
Prim( {{ListaId}} )= id
Prim( {{R1}} )= , ;
Prim( {{BloqueProg}} )= inicio
Prim( {{ListaProp}} )= £ si mientras hacer desde id leer escribir
Prim( {{PropSi}} )= si
Prim( {{R2}} )= £ sino
Prim( {{PropMientras}} )= mientras
Prim( {{PropHacer}} )= hacer
Prim( {{PropDesde}} )= desde
Prim( {{PropAsig}} )= id
Prim( {{PropLeer}} )= leer
Prim( {{PropEscribir}} )= escribir
Prim( {{A1}} )= id cadena
Prim( {{R3}} )= £ ,
Prim( {{Exp}} )= ( id ++ -- ! numero flotante
Prim( {{E}} )= ( id ++ -- ! numero flotante
Prim( {{F}} )= ( id ++ -- ! numero flotante
Prim( {{R5}} )= £ -- ++
Prim( {{E2}} )= £ + - * / % ^ || &&
Prim( {{R4}} )= £ oprel
Bitácora:
Del Prim({{ListaVar}}) al Prim({{Programa}}) con Ninguna Condición

Del Prim({{BloqueProg}}) al Prim({{Programa}}) con la Condición de £ en Prim({{ListaVar}})
Del Prim({{PropSi}}) al Prim({{ListaProp}}) con Ninguna Condición
Del Prim({{ListaProp}}) al Prim({{ListaProp}}) con la Condición de £ en Prim({{PropSi}})
Del Prim({{PropMientras}}) al Prim({{ListaProp}}) con Ninguna Condición
Del Prim({{ListaProp}}) al Prim({{ListaProp}}) con la Condición de £ en Prim({{PropMientras}})
Del Prim({{PropHacer}}) al Prim({{ListaProp}}) con Ninguna Condición
Del Prim({{ListaProp}}) al Prim({{ListaProp}}) con la Condición de £ en Prim({{PropHacer}})
Del Prim({{PropDesde}}) al Prim({{ListaProp}}) con Ninguna Condición
Del Prim({{ListaProp}}) al Prim({{ListaProp}}) con la Condición de £ en Prim({{PropDesde}})
Del Prim({{PropAsig}}) al Prim({{ListaProp}}) con Ninguna Condición
Del Prim({{ListaProp}}) al Prim({{ListaProp}}) con la Condición de £ en Prim({{PropAsig}})
Del Prim({{PropLeer}}) al Prim({{ListaProp}}) con Ninguna Condición
Del Prim({{ListaProp}}) al Prim({{ListaProp}}) con la Condición de £ en Prim({{PropLeer}})
Del Prim({{PropEscribir}}) al Prim({{ListaProp}}) con Ninguna Condición
Del Prim({{ListaProp}}) al Prim({{ListaProp}}) con la Condición de £ en Prim({{PropEscribir}})
Del Prim({{E}}) al Prim({{Exp}}) con Ninguna Condición
Del Prim({{R4}}) al Prim({{Exp}}) con la Condición de £ en Prim({{E}})
Del Prim({{F}}) al Prim({{E}}) con Ninguna Condición
Del Prim({{E2}}) al Prim({{E}}) con la Condición de £ en Prim({{F}})
36 de 75
Siguientes de la Gramática Factorizada a la Izquierda:
Sig( {{Programa}} )= $
Sig( {{ListaVar}} )= inicio
Sig( {{ListaId}} )= entero flotante caracter inicio
Sig( {{R1}} )= entero flotante caracter inicio
Sig( {{BloqueProg}} )= $
Sig( {{ListaProp}} )= }
Sig( {{PropSi}} )= si mientras hacer desde id leer escribir }
Sig( {{R2}} )= si mientras hacer desde id leer escribir }
Sig( {{PropMientras}} )= si mientras hacer desde id leer escribir }
Sig( {{PropHacer}} )= si mientras hacer desde id leer escribir }
Sig( {{PropDesde}} )= si mientras hacer desde id leer escribir }
Sig( {{PropAsig}} )= si mientras hacer desde id leer escribir } ( ++ -- ! numero flotante
Sig( {{PropLeer}} )= si mientras hacer desde id leer escribir }
Sig( {{PropEscribir}} )= si mientras hacer desde id leer escribir }
Sig( {{A1}} )= )
Sig( {{R3}} )= )
Sig( {{Exp}} )= ) ;
Sig( {{E}} )= oprel ) ;
Sig( {{F}} )= + - * / % ^ || && oprel ) ;
Sig( {{R5}} )= + - * / % ^ || && oprel ) ;
Sig( {{E2}} )= oprel ) ;
Sig( {{R4}} )= ) ;
Bitácora:
Del Prim({{Programa}}) al Prim({{BloqueProg}})

Del Prim({{ListaVar}}) al Prim({{ListaId}})
Del Prim({{ListaId}}) al Prim({{R1}})
Del Prim({{R1}}) al Prim({{ListaId}})
Del Prim({{ListaProp}}) al Prim({{PropSi}})
Del Prim({{ListaProp}}) al Prim({{PropMientras}})
Del Prim({{ListaProp}}) al Prim({{PropHacer}})
Del Prim({{ListaProp}}) al Prim({{PropDesde}})
Del Prim({{ListaProp}}) al Prim({{PropAsig}})
Del Prim({{ListaProp}}) al Prim({{PropLeer}})
Del Prim({{ListaProp}}) al Prim({{PropEscribir}})
Del Prim({{PropSi}}) al Prim({{R2}})
Del Prim({{A1}}) al Prim({{R3}})
Del Prim({{Exp}}) al Prim({{E}})
Del Prim({{Exp}}) al Prim({{R4}})
Del Prim({{E}}) al Prim({{F}})
Del Prim({{E}}) al Prim({{E2}})
Del Prim({{F}}) al Prim({{R5}})
Del Prim({{E2}}) al Prim({{F}})
Del Prim({{R4}}) al Prim({{E}})
37 de 75
Tabla M de la Gramática Factorizada a la Izquierda:
X: {{Programa}} A: $ Prod.: {{Programa}} -> {{ListaVar}} {{BloqueProg}}

X: {{Programa}} A: entero Prod.: {{Programa}} -> {{ListaVar}} {{BloqueProg}}
X: {{Programa}} A: flotante Prod.: {{Programa}} -> {{ListaVar}} {{BloqueProg}}
X: {{Programa}} A: caracter Prod.: {{Programa}} -> {{ListaVar}} {{BloqueProg}}
X: {{Programa}} A: inicio Prod.: {{Programa}} -> {{ListaVar}} {{BloqueProg}}
X: {{ListaVar}} A: entero Prod.: {{ListaVar}} -> entero {{ListaId}} {{ListaVar}}
X: {{ListaVar}} A: flotante Prod.: {{ListaVar}} -> flotante {{ListaId}} {{ListaVar}}
X: {{ListaVar}} A: caracter Prod.: {{ListaVar}} -> caracter {{ListaId}} {{ListaVar}}
X: {{ListaVar}} A: inicio Prod.: {{ListaVar}} -> £
X: {{ListaId}} A: id Prod.: {{ListaId}} -> id {{R1}}
X: {{R1}} A: , Prod.: {{R1}} -> , {{ListaId}}
X: {{R1}} A: ; Prod.: {{R1}} -> ;
X: {{BloqueProg}} A: inicio Prod.: {{BloqueProg}} -> inicio { {{ListaProp}} } fin
X: {{ListaProp}} A: si Prod.: {{ListaProp}} -> {{PropSi}} {{ListaProp}}
X: {{ListaProp}} A: mientras Prod.: {{ListaProp}} -> {{PropMientras}} {{ListaProp}}
X: {{ListaProp}} A: hacer Prod.: {{ListaProp}} -> {{PropHacer}} {{ListaProp}}
X: {{ListaProp}} A: desde Prod.: {{ListaProp}} -> {{PropDesde}} {{ListaProp}}
X: {{ListaProp}} A: id Prod.: {{ListaProp}} -> {{PropAsig}} {{ListaProp}}
X: {{ListaProp}} A: leer Prod.: {{ListaProp}} -> {{PropLeer}} {{ListaProp}}
X: {{ListaProp}} A: escribir Prod.: {{ListaProp}} -> {{PropEscribir}} {{ListaProp}}
X: {{ListaProp}} A: } Prod.: {{ListaProp}} -> £
X: {{PropSi}} A: si Prod.: {{PropSi}} -> si ( {{Exp}} ) { {{ListaProp}} } {{R2}}
X: {{R2}} A: sino Prod.: {{R2}} -> sino { {{ListaProp}} }
X: {{R2}} A: si Prod.: {{R2}} -> £
X: {{R2}} A: mientras Prod.: {{R2}} -> £
X: {{R2}} A: hacer Prod.: {{R2}} -> £
X: {{R2}} A: desde Prod.: {{R2}} -> £
X: {{R2}} A: id Prod.: {{R2}} -> £
X: {{R2}} A: leer Prod.: {{R2}} -> £
X: {{R2}} A: escribir Prod.: {{R2}} -> £
X: {{R2}} A: } Prod.: {{R2}} -> £
X: {{PropMientras}}A: mientras Prod.: {{PropMientras}} -> mientras ( {{Exp}} ) { {{ListaProp}} }
X: {{PropHacer}} A: hacer Prod.: {{PropHacer}} -> hacer { {{ListaProp}} } mientras ( {{Exp}} ) ;
X: {{PropDesde}} A: desde Prod.: {{PropDesde}} -> desde ( {{PropAsig}} {{Exp}} ; {{Exp}} ) { {{ListaProp}} }
X: {{PropAsig}} A: id Prod.: {{PropAsig}} -> id = {{Exp}} ;
X: {{PropLeer}} A: leer Prod.: {{PropLeer}} -> leer ( id ) ;
X: {{PropEscribir}} A: escribir Prod.: {{PropEscribir}} -> escribir ( {{A1}} ) ;
X: {{A1}} A: id Prod.: {{A1}} -> id
X: {{A1}} A: cadena Prod.: {{A1}} -> cadena {{R3}}
X: {{R3}} A: , Prod.: {{R3}} -> , id
X: {{R3}} A: ) Prod.: {{R3}} -> £
X: {{Exp}} A: ( Prod.: {{Exp}} -> {{E}} {{R4}}
X: {{Exp}} A: id Prod.: {{Exp}} -> {{E}} {{R4}}
X: {{Exp}} A: ++ Prod.: {{Exp}} -> {{E}} {{R4}}
X: {{Exp}} A: -- Prod.: {{Exp}} -> {{E}} {{R4}}
X: {{Exp}} A: ! Prod.: {{Exp}} -> {{E}} {{R4}}
X: {{Exp}} A: numero Prod.: {{Exp}} -> {{E}} {{R4}}
X: {{Exp}} A: flotante Prod.: {{Exp}} -> {{E}} {{R4}}
X: {{E}} A: ( Prod.: {{E}} -> {{F}} {{E2}}
X: {{E}} A: id Prod.: {{E}} -> {{F}} {{E2}}
X: {{E}} A: ++ Prod.: {{E}} -> {{F}} {{E2}}
X: {{E}} A: -- Prod.: {{E}} -> {{F}} {{E2}}
X: {{E}} A: ! Prod.: {{E}} -> {{F}} {{E2}}
X: {{E}} A: numero Prod.: {{E}} -> {{F}} {{E2}}
X: {{E}} A: flotante Prod.: {{E}} -> {{F}} {{E2}}
X: {{F}} A: ( Prod.: {{F}} -> ( {{Exp}} )
X: {{F}} A: id Prod.: {{F}} -> id {{R5}}
X: {{F}} A: ++ Prod.: {{F}} -> ++ id
X: {{F}} A: -- Prod.: {{F}} -> -- id
X: {{F}} A: ! Prod.: {{F}} -> ! {{F}}
X: {{F}} A: numero Prod.: {{F}} -> numero
X: {{F}} A: flotante Prod.: {{F}} -> flotante
X: {{R5}} A: -- Prod.: {{R5}} -> --
X: {{R5}} A: ++ Prod.: {{R5}} -> ++
X: {{R5}} A: + Prod.: {{R5}} -> £
X: {{R5}} A: - Prod.: {{R5}} -> £
X: {{R5}} A: * Prod.: {{R5}} -> £
X: {{R5}} A: / Prod.: {{R5}} -> £
38 de 75
X: {{R5}} A: % Prod.: {{R5}} -> £

X: {{R5}} A: ^ Prod.: {{R5}} -> £
X: {{R5}} A: || Prod.: {{R5}} -> £
X: {{R5}} A: && Prod.: {{R5}} -> £
X: {{R5}} A: oprel Prod.: {{R5}} -> £
X: {{R5}} A: ) Prod.: {{R5}} -> £
X: {{R5}} A: ; Prod.: {{R5}} -> £
X: {{E2}} A: + Prod.: {{E2}} -> + {{F}} {{E2}}
X: {{E2}} A: - Prod.: {{E2}} -> - {{F}} {{E2}}
X: {{E2}} A: * Prod.: {{E2}} -> * {{F}} {{E2}}
X: {{E2}} A: / Prod.: {{E2}} -> / {{F}} {{E2}}
X: {{E2}} A: % Prod.: {{E2}} -> % {{F}} {{E2}}
X: {{E2}} A: ^ Prod.: {{E2}} -> ^ {{F}} {{E2}}
X: {{E2}} A: || Prod.: {{E2}} -> || {{F}} {{E2}}
X: {{E2}} A: && Prod.: {{E2}} -> && {{F}} {{E2}}
X: {{E2}} A: oprel Prod.: {{E2}} -> £
X: {{E2}} A: ) Prod.: {{E2}} -> £
X: {{E2}} A: ; Prod.: {{E2}} -> £
X: {{R4}} A: oprel Prod.: {{R4}} -> oprel {{E}}
X: {{R4}} A: ) Prod.: {{R4}} -> £
X: {{R4}} A: ; Prod.: {{R4}} -> £
39 de 75
Implementación
La implementación del Análisis Sintáctico, esta definida en los siguientes Módulos:
Sintáctico.h
//---------------------------------------------------------------------------
#ifndef SintacticoH
#define SintacticoH
//---------------------------------------------------------------------------
#include "Lexico.h"
#define MAX 3000
const int NOVTS = 36;
const int NOVNS = 23;
const int ANCHOVNS = 16;
const int NOPROD = 53;
const int NOYES = 10;
const int NOENT = 89;
const int MAXDIS = 1000;
//---------------------------------------------------------------------------
class Pila
{
private:
char Datos[MAX][255];
int Tope;
public:
void Inicia();
void Push (char*);
char* Pop ();
bool Empty ();
char* E(int);
int RetTope();
char* StackTop();
};
//---------------------------------------------------------------------------
class Sintactico
{
private:
Pila oPila;
char VTS[NOVTS][ANCHOTOKEN];
char VNS[NOVNS][ANCHOVNS];
int Prod[NOPROD][NOYES+2];
int M[NOENT][3];
int iNoDis;
int DIS[MAXDIS];
int iNoProd;
int EsTerminal(char *);
int Busqueda(char* , char*);
void MeterYes(int);
char Error[MAXDIS][ANCHOTOKEN];
int TipoError[MAXDIS];
int RenglonError[MAXDIS];
int iNoError;
int iNoRenglon;
public:
void Inicia();
int Analiza(Lexico);
char* RetProdNo(int);
char* RetVTNo(int i){return VTS[i];};
char* RetVNNo(int i){return VNS[i];};
int RetValM(int,int);
int RetNoDis(){return iNoDis;};
int RetDIS(int i){return DIS[i];};
int RetElemProdNo(int i, int j){return Prod[i][j];};
char* RetError(int i){return Error[i];};
int RetRenError(int i){return RenglonError[i];};
int RetTipoError(int i){return TipoError[i];};
int RetNoError(){return iNoError;};
40 de 75
};
//---------------------------------------------------------------------------
#endif
Sintáctico.cpp
//---------------------------------------------------------------------------
#pragma hdrstop
#include "Sintactico.h"
#include "Lexico.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
char sProd[255];
//---------------------------------------------------------------------------
void Pila::Inicia()
{
Tope=-1;
}
//---------------------------------------------------------------------------
void Pila::Push (char* Elemento)
{
if((Tope+1)==MAX)
{
Application->MessageBox("Desbordamiento","Error",MB_OK);
}
else
{
Tope++;
strcpy(Datos[Tope],Elemento);
}
}
//---------------------------------------------------------------------------
char* Pila::Pop ()
{
char* Elemento;
if(Empty())
{
Application->MessageBox("Subdesdordamiento","Error",MB_OK);
}
else
{
Elemento=Datos[Tope];
Tope--;
}
return Elemento;
}
//---------------------------------------------------------------------------
bool Pila::Empty ()
{
if(Tope==-1)
{
return true;
}
else
{
return false;
}
}
//---------------------------------------------------------------------------
char* Pila::E(int i)
{
return Datos[i];
}
//---------------------------------------------------------------------------
41 de 75
int Pila::RetTope()
{
return Tope;
}
//---------------------------------------------------------------------------
char* Pila::StackTop()
{
char* Elemento="";
if(Empty())
{
Application->MessageBox("Pila Vacía","Error",MB_OK);
}
else
{
Elemento=Datos[Tope];
}
return Elemento;
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
void Sintactico::Inicia()
{
iNoDis=iNoError=iNoRenglon=0;
char AuxVNS[NOVNS][ANCHOVNS]={"","Programa\0","ListaVar\0","ListaId\0","R1\0","BloqueProg\0","ListaProp\
0","PropSi\0","R2\0","PropMientras\0","PropHacer\0","PropDesde\0","PropAsig\0","PropLeer\0","PropEscribir\
0","A1\0","R3\0","Exp\0","E\0","F\0","R5\0","E2\0","R4\0"};
for(int i=0;i<NOVNS;i++)
{
strcpy(VNS[i],AuxVNS[i]);
}
char AuxVTS[NOVTS][ANCHOTOKEN]={"","entero\0","flotante\0","caracter\0","id\0",",\0",";\0","inicio\0","{\0","}\
0","fin\0","si\0","(\0",")\0","sino\0","mientras\0","hacer\0","desde\0","=\0","leer\0","escribir\0","cadena\0","++\0","--\0","!\
0","numero\0","+\0","-\0","*\0","/\0","%\0","^\0","||\0","&&\0","oprel\0","$\0"};
for(int i=0;i<NOVTS;i++)
{
strcpy(VTS[i],AuxVTS[i]);
}
int AuxProd[NOPROD][NOYES+2]={ 1,2,2,5,0,0,0,0,0,0,0,0, //Programa -> ListaVar
BloqueProg
2,3,-1,3,2,0,0,0,0,0,0,0, //ListaVar -> entero ListaId
ListaVar
2,3,-2,3,2,0,0,0,0,0,0,0, //ListaVar -> flotante ListaId
ListaVar
2,3,-3,3,2,0,0,0,0,0,0,0, //ListaVar -> caracter ListaId
ListaVar
2,0,0,0,0,0,0,0,0,0,0,0, //ListaVar -> £
3,2,-4,4,0,0,0,0,0,0,0,0, //ListaId -> id R1
4,2,-5,3,0,0,0,0,0,0,0,0, //R1 -> , ListaId
4,1,-6,0,0,0,0,0,0,0,0,0, //R1 -> ;
5,5,-7,-8,6,-9,-10,0,0,0,0,0, //BloqueProg -> inicio { ListaProp }
fin
6,2,7,6,0,0,0,0,0,0,0,0, //ListaProp -> PropSi ListaProp
6,2,9,6,0,0,0,0,0,0,0,0, //ListaProp -> PropMientras
ListaProp
6,2,10,6,0,0,0,0,0,0,0,0, //ListaProp -> PropHacer
ListaProp
6,2,11,6,0,0,0,0,0,0,0,0, //ListaProp -> PropDesde
ListaProp
6,2,12,6,0,0,0,0,0,0,0,0, //ListaProp -> PropAsig ListaProp
6,2,13,6,0,0,0,0,0,0,0,0, //ListaProp -> PropLeer ListaProp
6,2,14,6,0,0,0,0,0,0,0,0, //ListaProp -> PropEscribir
ListaProp
6,0,0,0,0,0,0,0,0,0,0,0, //ListaProp -> £
7,8,-11,-12,17,-13,-8,6,-9,8,0,0, //PropSi -> si ( Exp ) { ListaProp }
R2
8,4,-14,-8,6,-9,0,0,0,0,0,0, //R2 -> sino { ListaProp }
8,0,0,0,0,0,0,0,0,0,0,0, //R2 -> £
9,7,-15,-12,17,-13,-8,6,-9,0,0,0, //PropMientras -> mientras ( Exp )
{ ListaProp }
42 de 75
10,9,-16,-8,6,-9,-15,-12,17,-13,-6,0, //PropHacer -> hacer { ListaProp }

mientras ( Exp ) ;
11,10,-17,-12,12,17,-6,17,-13,-8,6,-9, //PropDesde -> desde ( PropAsig
Exp ; Exp ) { ListaProp }
12,4,-4,-18,17,-6,0,0,0,0,0,0, //PropAsig -> id = Exp ;
13,5,-19,-12,-4,-13,-6,0,0,0,0,0, //PropLeer -> leer ( id ) ;
14,5,-20,-12,15,-13,-6,0,0,0,0,0, //PropEscribir -> escribir ( A1 ) ;
15,1,-4,0,0,0,0,0,0,0,0,0, //A1 -> id
15,2,-21,16,0,0,0,0,0,0,0,0, //A1 -> cadena R3
16,2,-5,-4,0,0,0,0,0,0,0,0, //R3 -> , id
16,0,0,0,0,0,0,0,0,0,0,0, //R3 -> £
17,2,18,22,0,0,0,0,0,0,0,0, //Exp -> E R4
18,2,19,21,0,0,0,0,0,0,0,0, //E -> F E2
19,3,-12,17,-13,0,0,0,0,0,0,0, //F -> ( Exp )
19,2,-4,20,0,0,0,0,0,0,0,0, //F -> id R5
19,2,-22,-4,0,0,0,0,0,0,0,0, //F -> ++ id
19,2,-23,-4,0,0,0,0,0,0,0,0, //F -> -- id
19,2,-24,19,0,0,0,0,0,0,0,0, //F -> ! F
19,1,-25,0,0,0,0,0,0,0,0,0, //F -> num
19,1,-2,0,0,0,0,0,0,0,0,0, //F -> flotante
20,1,-23,0,0,0,0,0,0,0,0,0, //R5 -> --
20,1,-22,0,0,0,0,0,0,0,0,0, //R5 -> ++
20,0,0,0,0,0,0,0,0,0,0,0, //R5 -> £
21,3,-26,19,21,0,0,0,0,0,0,0, //E2 -> + F E2
21,3,-27,19,21,0,0,0,0,0,0,0, //E2 -> - F E2
21,3,-28,19,21,0,0,0,0,0,0,0, //E2 -> * F E2
21,3,-29,19,21,0,0,0,0,0,0,0, //E2 -> / F E2
21,3,-30,19,21,0,0,0,0,0,0,0, //E2 -> % F E2
21,3,-31,19,21,0,0,0,0,0,0,0, //E2 -> ^ F E2
21,3,-32,19,21,0,0,0,0,0,0,0, //E2 -> || F E2
21,3,-33,19,21,0,0,0,0,0,0,0, //E2 -> && F E2
21,0,0,0,0,0,0,0,0,0,0,0, //E2 -> £
22,2,-34,18,0,0,0,0,0,0,0,0, //R4 -> oprel E
22,0,0,0,0,0,0,0,0,0,0,0 //R4 -> £
};
for(int i=0;i<NOPROD;i++)
{
for(int j=0;j<NOYES+2;j++)
{
Prod[i][j]=AuxProd[i][j];
}
}
int AuxM[NOENT][3] = { 1,35,0, //X: {{Programa}} A: $
1,1,0, //X: {{Programa}} A: entero
1,2,0, //X: {{Programa}} A: flotante
1,3,0, //X: {{Programa}} A: caracter
1,7,0, //X: {{Programa}} A: inicio
2,1,1, //X: {{ListaVar}} A: entero
2,2,2, //X: {{ListaVar}} A: flotante
2,3,3, //X: {{ListaVar}} A: caracter
2,7,4, //X: {{ListaVar}} A: inicio
3,4,5, //X: {{ListaId}} A: id
4,5,6, //X: {{R1}} A: ,
4,6,7, //X: {{R1}} A: ;
5,7,8, //X: {{BloqueProg}} A: inicio
6,11,9, //X: {{ListaProp}} A: si
6,15,10, //X: {{ListaProp}} A: mientras
6,16,11, //X: {{ListaProp}} A: hacer
6,17,12, //X: {{ListaProp}} A: desde
6,4,13, //X: {{ListaProp}} A: id
6,19,14, //X: {{ListaProp}} A: leer
6,20,15, //X: {{ListaProp}} A: escribir
6,9,16, //X: {{ListaProp}} A: }
7,11,17, //X: {{PropSi}} A: si
8,14,18, //X: {{R2}} A: sino
8,11,19, //X: {{R2}} A: si
8,15,19, //X: {{R2}} A: mientras
8,16,19, //X: {{R2}} A: hacer
8,17,19, //X: {{R2}} A: desde
43 de 75
8,4,19, //X: {{R2}} A: id

8,19,19, //X: {{R2}} A: leer
8,20,19, //X: {{R2}} A: escribir
8,9,19, //X: {{R2}} A: }
9,15,20, //X: {{PropMientras}} A: mientras
10,16,21, //X: {{PropHacer}} A: hacer
11,17,22, //X: {{PropDesde}} A: desde
12,4,23, //X: {{PropAsig}} A: id
13,19,24, //X: {{PropLeer}} A: leer
14,20,25, //X: {{PropEscribir}} A: escribir
15,4,26, //X: {{A1}} A: id
15,21,27, //X: {{A1}} A: cadena
16,5,28, //X: {{R3}} A: ,
16,13,29, //X: {{R3}} A: )
17,12,30, //X: {{Exp}} A: (
17,4,30, //X: {{Exp}} A: id
17,22,30, //X: {{Exp}} A: ++
17,23,30, //X: {{Exp}} A: --
17,24,30, //X: {{Exp}} A: !
17,25,30, //X: {{Exp}} A: num
17,2,30, //X: {{Exp}} A: flotante
18,12,31, //X: {{E}} A: (
18,4,31, //X: {{E}} A: id
18,22,31, //X: {{E}} A: ++
18,23,31, //X: {{E}} A: --
18,24,31, //X: {{E}} A: !
18,25,31, //X: {{E}} A: num
18,2,31, //X: {{E}} A: flotante
19,12,32, //X: {{F}} A: (
19,4,33, //X: {{F}} A: id
19,22,34, //X: {{F}} A: ++
19,23,35, //X: {{F}} A: --
19,24,36, //X: {{F}} A: !
19,25,37, //X: {{F}} A: num
19,2,38, //X: {{F}} A: flotante
20,23,39, //X: {{R5}} A: --
20,22,40, //X: {{R5}} A: ++
20,26,41, //X: {{R5}} A: +
20,27,41, //X: {{R5}} A: -
20,28,41, //X: {{R5}} A: *
20,29,41, //X: {{R5}} A: /
20,30,41, //X: {{R5}} A: %
20,31,41, //X: {{R5}} A: ^
20,32,41, //X: {{R5}} A: ||
20,33,41, //X: {{R5}} A: &&
20,34,41, //X: {{R5}} A: oprel
20,13,41, //X: {{R5}} A: )
20,6,41, //X: {{R5}} A: ;
21,26,42, //X: {{E2}} A: +
21,27,43, //X: {{E2}} A: -
21,28,44, //X: {{E2}} A: *
21,29,45, //X: {{E2}} A: /
21,30,46, //X: {{E2}} A: %
21,31,47, //X: {{E2}} A: ^
21,32,48, //X: {{E2}} A: ||
21,33,49, //X: {{E2}} A: &&
21,34,50, //X: {{E2}} A: oprel
21,13,50, //X: {{E2}} A: )
21,6,50, //X: {{E2}} A: ;
22,34,51, //X: {{R4}} A: oprel
22,13,52, //X: {{R4}} A: )
22,6,52 //X: {{R4}} A: ;
};
for(int i=0;i<NOENT;i++)
{
for(int j=0;j<3;j++)
{
M[i][j]=AuxM[i][j];
}
44 de 75
}
}
//---------------------------------------------------------------------------
int Sintactico::EsTerminal(char *px)
{
{
if(strcmp(px,VTS[i])==0)
{
return 1;
}
}
return 0;
}
//---------------------------------------------------------------------------
int Sintactico::Busqueda(char *px, char *pa)
{
int iIndx, iInda;
for(int i=0;i<NOVNS;i++)
{
if(strcmp(px,VNS[i])==0)
{
iIndx=i;
break;
}
}
{
if(strcmp(pa,VTS[i])==0)
{
iInda=i;
break;
}
}
for(int i=0;i<NOENT;i++)
{
if(M[i][0]==iIndx && M[i][1]==iInda)
{
return M[i][2];
}
}
return -1;
}
//---------------------------------------------------------------------------
void Sintactico::MeterYes(int iNoProd)
{
int iNoyes=Prod[iNoProd][1];
int iCol=iNoyes+2;
for(int i=1;i<=iNoyes;i++)
{
if((Prod[iNoProd][iCol-i])<0)
{
oPila.Push(RetVTNo(-Prod[iNoProd][iCol-i]));
}
else
{
oPila.Push(RetVNNo(Prod[iNoProd][iCol-i]));
}
}
}
//---------------------------------------------------------------------------
int Sintactico::Analiza(Lexico oAnalex)
{
int AE, Error1=false;
char X[ANCHOTOKEN], A[ANCHOTOKEN];
oPila.Inicia();
oPila.Push("$");
//Símbolo de inicio
oPila.Push("Programa");
AE=0;
45 de 75
oAnalex.Anade("$");
do
{
strcpy(X,oPila.StackTop());
strcpy(A,oAnalex.RetToken(AE));
if(EsTerminal(X))
{
if(strcmp(X,A)==0)
{
oPila.Pop();
AE++;
}
else
{
Error1=true;
strcpy(Error[iNoError],X);
TipoError[iNoError]=1;
iNoRenglon=oAnalex.RetDirEnter(AE);
RenglonError[iNoError]=iNoRenglon;
iNoError++;
oPila.Pop();
AE++;
//return 1;
}
}
else
{
if((iNoProd=Busqueda(X,A))>=0)
{
oPila.Pop();
MeterYes(iNoProd);
DIS[iNoDis++]=iNoProd;
}
else
{
AnsiString DefinicionError1;
DefinicionError1 = AnsiString(X) + " : " + AnsiString(A);
strcpy(Error[iNoError],DefinicionError1.c_str());
TipoError[iNoError]=2;
iNoRenglon=oAnalex.RetDirEnter(AE);
RenglonError[iNoError]=iNoRenglon;
iNoError++;
return 2;
}
}
}while(strcmp(X,"$")!=0);
if(Error1)
{
return 1;
}
return 0;
}
//---------------------------------------------------------------------------
char* Sintactico::RetProdNo(int iNoProd)
{
strcpy(sProd,RetVNNo(Prod[iNoProd][0]));
strcat(sProd," -> ");
for(int i=0;i<Prod[iNoProd][1];i++)
{
if(Prod[iNoProd][i+2]<0)
{
strcat(sProd,RetVTNo(-Prod[iNoProd][i+2]));
}
else
{
strcat(sProd,RetVNNo(Prod[iNoProd][i+2]));
}
strcat(sProd," ");
}
return sProd;
46 de 75
}
//---------------------------------------------------------------------------
int Sintactico::RetValM(int iNoEnt,int Col)
{
return M[iNoEnt][Col];
}
//---------------------------------------------------------------------------
47 de 75
3.- Análisis Semántico
Esta Pestaña Muestra el Análisis Semántico que se ha

realizado al Archivo de Código Activo. Hace referencia a
los Identificadores que se han reconocido. La descripción
de los Elementos que conforman este Análisis es la
siguiente:
 Archivo de Código Activo

 Tipo de Variable
 Variable
Este Análisis se realiza en base al Léxico realizado, sigue un Algoritmo de Comprobación de Tipos,
Flujo de Control y Unicidad que permiten determinar el significado de las palabras utilizadas en
contextos específicos de una manera sistemática y objetiva, haciendo referencia a una gama de
expresiones. El Análisis Semántico identifica 3 tipos de incoherencias:
 Identificadores Doblemente Declaradas. Ocurre al declarar más de una vez un mismo

Identificador.
 Identificadores No Declaradas. Se presenta al utilizar un Identificador sin haberlo

declarado.
 No coincidencia de Tipos. Se presenta al no existir concordancia con los tipos de los

identificadores.
48 de 75
Implementación
La implementación del Análisis Semántico, esta definida en los siguientes Módulos:
Semántico.h
//---------------------------------------------------------------------------
#ifndef SemanticoH
#define SemanticoH
//---------------------------------------------------------------------------
#include "Lexico.h"
#define MAXVariables 500 //Cantidad de Variables Declaradas
#define MAXTipoDeclaraciones 3 //Cantidad de Tipos de Declaraciones
#define MAXTipos 3 //Cantidad de Tipos de Datos
#define MAXTipoEstCont 2 //Cantidad de Estructuras de Control a Revisar los Tipos
#define MAXTermTipoEstCont 2 //Cantidad de Terminaciones para las Estructuras de Control a Revisar los Tipos
#define MAXErrores 1000
//---------------------------------------------------------------------------
class Semantico
{
private:
int iNoError;
int iNoRenglon;
int iNoVariables;
char Errores[MAXErrores][255];
char DefID[255];
char DefTermDec[255];
char DefIniProg[255];
char DefAsig[255];
char DefDesde[255];
char DefSepDesde[255];
char DefTermAsig[255];
char DefEstCont[MAXTipoEstCont][255];
char DefTermEstCont[MAXTermTipoEstCont][255];
int TipoError[MAXErrores];
int RenError[MAXErrores];
char TipoDeclaraciones[MAXTipoDeclaraciones][255];
char TipoDato[MAXTipos][255];
int TipoTipoDato[MAXTipos];
char Variables[MAXVariables][255];
int TipoVariables[MAXVariables];
int Insertar(char*,int);
int Buscar(char*);
int EsDeclaracion(char*,int&);
int EsDato(char*,int&);
int EsEstructuradeControl(char*);
int EsTerminodeEstructuradeControl(char*);
public:
void Inicia();
int Analiza(Lexico);
int RetiNoError(){return iNoError;};
char* RetError(int i){return Errores[i];};
int RetTipoError(int i){return TipoError[i];};
int RetRenError(int i){return RenError[i];};
char* RetTipoDeclaraciones(int i){return TipoDeclaraciones[i];};
int RetiNoVariables(){return iNoVariables;};
int RetTipoVariables(int i){return TipoVariables[i];};
char* RetVariables(int i){return Variables[i];};
};
//---------------------------------------------------------------------------
#endif
49 de 75
Ventana de Errores
El aspecto de la Ventana de Errores es el siguiente:
En esta ventana se muestran los errores que se encuentran en el Código Fuente al realizar una
Compilación (Análisis Léxico, Sintáctico y Semántico).
Esta conformada por 3 Columnas:
1. Evento: Esta Columna Muestra el tipo de Error ocurrido (Léxico, Sintáctico ó Semántico).
2. Descripción: Esta Columna Informa Detalladamente el Tipo de Error ocurrido.
3. Línea: La última Columna indica en que Línea del SynEdit aparece dicho Error.
Muestra 3 tipos de Errores.
1.- Errores Léxicos
Se presentan cuando se introducen caracteres no válidos. Por ejemplo:
Carácter no Válido ' '

En este caso el Error esta en que no se debe de introducir el caracter #, la solución es eliminar ese
caracter.
50 de 75
2.- Errores Sintácticos
Se presentan cuando no se cumplen las Reglas de la Gramática de Visual Algory. Por ejemplo:
Se esperaba ' '

Este Error se debe, a que un Código Fuente debe seguir las reglas del Análisis Sintáctico, pero el
Token que se esperaba se omitió. La solución es poner inmediatamente después del último Token
correcto el Token omitido.
Error de Sintaxis
Se da cuando no se siguen las Reglas de la Gramática de Visual Algory.
51 de 75
3.- Errores Semánticos
Se presentan cuando la Semántica del Código Fuente no se entiende. Por ejemplo:
Variable No Declarada ' '

Este Error se presenta al utilizar un Identificador sin haberlo declarado, la solución es declararlo o
eliminarlo.
Variable Doblemente Declarada ' '

Este Error ocurre al declarar más de una vez un mismo Identificador, la solución es eliminar una
declaración.
No Coinciden los Tipos ' '

Este Error se presenta al no haber correspondencia de tipos en operaciones matemáticas o
expresiones.
52 de 75
Estatus Bar
El aspecto del Estatus Bar es el siguiente:
Está formado por 4 Paneles:
1. El 1er Panel despliega la Ubicación del Cursor (Reglón : Columna).

2. El 2o Panel informa si el SynEdit ha sufrido Modificaciones.
3. El 3er Panel muestra la información del Punto de Inserción (Ins para Insertar, Sob para
Sobrescribir).
4. El 4o Panel informa el Nombre del Archivo de Código Activo.
53 de 75
Código
El aspecto del Código es el siguiente:
Esta formado por 2 pestañas:
1. Código Fuente
Se constituye de un SynEdit
Este Componente del Código, permite estructurar un Código Fuente, al cual se le realizarán los
Análisis pertinentes y la Simulación adecuada, consta de un Gutter.
54 de 75
Instrucciones Reconocidas
La Gramática implementada reconoce las Instrucciones Básicas de Algory, como son:
 Declaraciones Sencillas de Variables (entero x;)

 Un Bloque de Instrucciones (inicio{}fin)
o Proposiciones Sencillas
 si
 si-sino
 mientras
 hacer-mientras
 desde
 leer
 escribir
 Asignaciones
o Tres tipos de Datos (Entero, Flotante, Cadena)
Instrucciones a las que se les genera Código Intermedio
1. Instrucción si-sino
Ejemplo Código Intermedio Generado

Número Instrucción
si(A==B) 0 Valor_D
{ 1 A
A=7; 2 Valor_D
} 3 B
sino
4 ==
{
A=9; 5 Si_Falso_Vea
} 6 14
7 Valor_I
8 A
9 Inserta
10 7
11 =
12 Vea
13 21
14 Etiqueta
15 14
16 Valor_I
17 A
18 Inserta
19 9
20 =
21 Eriqueta
22 21
55 de 75
2. Instrucción mientras

mientras(A<B) 0 Etiqueta
{ 1 0
A=A+1; 2 Valor_D
} 3 A
4 Valor_D
5 B
6 <
7 Si_Falso_Vea
8 19
9 Valor_I
10 A
11 Valor_D
12 A
13 Inserta
14 1
15 +
16 =
17 Vea
18 0
19 Etiqueta
20 19
3. Instrucción hacer-mientras

hacer 0 Etiqueta
{ 1 0
A=A+1; 2 Valor_I
}mientras(A<B); 3 B
4 Valor_D
5 B
6 Valor_D
7 A
8 +
9 =
10 Valor_D
11 B
12 Inserta
13 5
14 !=
15 Si_Cierto_Vea
16 0
56 de 75
4. Instrucción desde

desde(I=0;I<=B;I++) 0 Valor_I
{ 1 I
2 Inserta
B=B+I; 3 0
} 4 =
5 Etiqueta
6 5
7 Valor_D
8 I
9 Valor_D
10 B
11 <=
12 Si_Falso_Vea
13 35
14 Vea
15 23
16 Etiqueta
17 16
18 Valor_D
19 I
20 ++
21 Vea
22 5
23 Etiqueta
24 23
25 Valor_I
26 B
27 Valor_D
28 B
29 Valor_D
30 I
31 +
32 =
33 Vea
34 16
35 Etiqueta
36 35
5. Instrucción leer

leer(x); 0 Leer
1 X
6. Instrucción escribir

0 Escribir
escribir("Hola",x); 1 “Hola”
2 X
3 Fin_Escribir
57 de 75
Autocompletar
El SynEdit posee una función denominada Autocompletar, la cual consiste en llenar con ciertos
caracteres una entrada válida para esta función. La forma de activar esta función es:
1.- Posicionarse inmediatamente después de la entrada válida (sin espacios).

2.- Presionar Shift + Espacio.
3.- Inmediatamente después aparecerá el resultado de activar esta función, para la entrada válida.
Las entradas válidas para esta función son:
INI, lo que produce:
inicio
{
|
}
fin
L, lo que produce:
leer(|);
SI, lo que produce:
si(|)
{
SN, lo que produce:
si(|)
{
}
sino
{
M, lo que produce:
mientras(|)
{
H, lo que produce:
hacer
{
}mientras(|);
D, lo que produce:
desde(|;;)
{
58 de 75
ES, lo que produce:
escribir(|);
E, lo que produce:
entero |;
F, lo que produce:
flotante |;
C, lo que produce:
caracter |;
Donde | es el Punto de Inserción.
59 de 75
2. Código Intermedio y Tabla de Símbolos
Está constituido por un Código Intermedio y una Tabla de Símbolos
Código Intermedio, posee 3 Columnas:
1. No.: Dirección de Memoria para una Instrucción

2. Instrucción: Microinstrucción de un Código Fuente
3. Equiv.: Equivalencia del la Instrucción de a cuerdo a una Tabla de Equivalencias
Tipo de Código Intermedio generado
El código intermedio es una estructura de código cuya complejidad está entre el código fuente en
lenguaje de alto nivel y el código maquina, los códigos intermedios se pueden considerar como la
interfaz entre el generador de código y las fases previas del compilador. Las clases de código
intermedio usadas más comunes son:
 Notación postfija: x y + x y * -
 Código de tres direcciones (cuádruples): Op. Arg1. Arg2. Res.
 Código de dos direcciones (triples): Op.Arg1. Arg2.
60 de 75
El tipo de código implementado fue el de la notación postfija para así poder implementar una
maquina de pila abstracta. Las instrucciones usadas para representar el código intermedio son:
 Aritméticas y lógicas:
{"==","+","-","*","/","%","^","|","&","++","--","<","<=","==","!=",">=",">","!","||","&&"}
 Manipulación de pila:
o Inserta V o Meter V.- Inserta V en la pila.

o Valor_D L.- Inserta el contenido de L en la pila.
o Valor_I L.- Inserta la dirección de L en la pila.
o Saca.- Obtiene el valor superior de la pila.
o =.- Se asigna el valor superior de la pila a la dirección señalada por el siguiente
dato en la pila.
o Copia.- Inserta copia del valor superior de pila.
 Control de flujo:
o Etiqueta L.- Destino de un salto a L.

o Vea.- Continua ejecución en etiqueta L.
o Si_Falso_Vea.- Saca valor de pila, salta a L si es igual a 0.
o Si_Cierto_Vea.- Saca valor de pila, salta a L si es diferente de 0.
o Alto.- Detiene la ejecución.
o Rutina X.- Salta o llama a subrutina X.
Ejemplo:
Código. Código Intermedio.

entero c; 0 Valor_I
inicio 1 c
{ 2 Inserta
c=20;
3 20
}fin
4 =
Tabla de Símbolos, esta formada por 5 Columnas:
1. No.: Número de Símbolo

2. Nombre: Nombre del Símbolo
3. Valor: Valor del Símbolo
4. Tipo: Tipo del Símbolo
5. Dirección: Dirección del Símbolo en la Tabla de Símbolos
Nota: un Símbolo representa una Variable.
61 de 75
Simulación
El aspecto de la Simulación es el siguiente:
Esta constituido por 4 secciones:
1. Ejecución
2. Secuencia de Operaciones
3. Barra de Opciones
4. Contenedor del Código Intermedio
62 de 75
Ejecución
Es un SynEdit en el cual se mostrará la Simulación del Código Intermedio, funcionará como una
consola de MS-DOS en la cual se podrá mostrar y recibir datos. En la Lectura de datos se mostrará
un cursor a la espera de información, para aceptar dicha información es necesario dar un Enter;
para cancelar la Simulación será necesario dar ESC.
Secuencia de Operaciones
Es un SynEdit en el cual se muestra la serie de Microinstrucciones realizadas al Simular el Código

Intermedio, se divide en 2 columnas; la primera es la Dirección de Memoria de la Instrucción y la
segunda es la Microinstrucción realizada.
Barra de Opciones
Es un Panel en el cual se pueden establecer las Opciones de Simulación del Código Intermedio,
cuenta con los siguientes elementos:
Realiza una Simulación al Código Intermedio

Establece si la Simulación se realiza Completa o Paso a Paso
Muestra el Número de Iteraciones realizadas durante la Simulación
Define el Número máximo de iteraciones para una simulación (pasos ó microinstrucciones)
Guarda en un Archivo txt el Contenido de la Ejecución
Guarda en un Archivo txt el Contenido de la Secuencia de Pasos
63 de 75
Contenedor del Código Intermedio
Está formado por 3 elementos:
1. C.I.
2. Variables
3. Pila
C.I.
Es el Código Intermedio generado a partir del Código

Fuente; aunque puede ser creado a partir del mismo, puede
ser cargado de un archivo de simulación ya compilado.
Variables
Son los identificadores declarados en el Código Fuente,

cada uno con su Número, Nombre, Valor, Tipo y Dirección
correspondiente.
Pila
Es la pila de operaciones utilizada para las instrucciones aritméticas y lógicas durante la

Simulación, el número a la izquierda se refiere a la posición del elemento en la pila, donde el mayor
esta en la primera posición y el 1 es el último.
64 de 75
Mensajes de Error y Recuperación
Mensajes de Error
1. Mensaje de Modificación
Ocurre al Abrir, Cerrar ó Crear un Archivo Nuevo y no se han guardado los cambios del Archivo de
Código Fuente Actual, es una medida de seguridad para evitar perder un Archivo modificado.
Si: Guarda el Archivo Actual llamando al diálogo de Guardar

No: Realiza la acción solicitada (Abrir, Cerrar ó Crear un Archivo Nuevo) sin Guardar nada
Cancelar: No realiza ninguna acción.
2. Mensaje de Error al Guardar
Se muestra al ocurrir un error al guardar el Archivo de Código Intermedio, es completamente ajeno

al funcionamiento de Visual Algory, ya que no se puede realizar el proceso de Fijación del Archivo.
3. Mensaje de Obtención de Código
Sucede al no poder generar el Código Intermedio, en teoría no se debería de presentar, sin

embargo puede que el manejo de la cantidad del código a generar sea demasiado y no pueda ser
procesado.
65 de 75
4. Mensaje de Ejecución
Ocurre al haber un error en la Compilación del Código Fuente, es muy posible que sea por que el
código posea errores que pasaron desapercibidos por alguno de los análisis realizados, sin
embargo otra causa podría ser que la cantidad del código a generar sea demasiado y no pueda ser
procesado.
5. Mensaje de Falta de Código
Se presenta cuando se quiso compilar un archivo en blanco.
6. Mensaje de Búsqueda
Se muestra al no encontrar un determinado elemento en la Búsqueda ó Reemplazo dentro del

Código Fuente ó en el SynEdit de Ejecución.
7. Mensaje de Simulación
Aparece al Terminar una Simulación de un Código Intermedio.
66 de 75
Sucede al momento de Simular un Código Intermedio y el número de Microinstrucciones realizadas

supera el Máximo de esas Iteraciones, esto se puede presentar por dos situaciones; la primera por
que el Código Intermedio a Simular es demasiado grande, para ello simplemente modifique el
Máximo de Iteraciones. La segunda es por que existe un ciclo infinito de instrucciones y no puede
terminar el programa.
Se muestra al Pausar la Simulación del Código Intermedio actual, esto debido a que se presionó
ESC en una entrada de datos durante la Simulación.
Se presenta cuando al Simular el Código Intermedio ocurre un error, la razón puede ser el tamaño
del Código a Simular.
67 de 75
11. Mensaje de Apertura
Ocurre al abrir un Archivo de Simulación y no se cuenta con el Archivo de Tabla de Símbolos

correspondiente, por lo que no se puede ejecutar la Simulación; una solución sería si se cuenta con
el Código Fuente, simplemente volver a compilarlo.
12. Mensaje de Desbordamiento
Aparece cuando existe un Desbordamiento de la Pila del Análisis Sintáctico.
13. Mensaje de Subdesbordamiento
Aparece cuando existe un Subdesbordamiento de la Pila del Análisis Sintáctico.
14. Mensaje de Pila Vacía
Aparece cuando existe una Pila Vacía en el Análisis Sintáctico.
68 de 75
15. Mensaje de Error al Guardar
Sucede al no poder Guardar la Tabla de Símbolos del Archivo de Código Fuente Actual, es
completamente ajeno al funcionamiento de Visual Algory, ya que no se puede realizar el proceso
de Fijación del Archivo.
16. Mensaje de Apertura
Aparece cuando no se puede Cargar el Archivo de Tabla de Símbolos del Archivo de Código
Fuente Actual, es completamente ajeno al funcionamiento de Visual Algory, ya que no se puede
realizar el proceso de Lectura del Archivo, es posible que no exista dicho archivo.
17. Mensaje de Desbordamiento
Aparece cuando existe un Desbordamiento de la Pila en la Simulación.
18. Mensaje de Subdesbordamiento
Aparece cuando existe un Subdesbordamiento de la Pila en la Simulación.
69 de 75
19. Mensaje de Pila Vacía
Aparece cuando existe una Pila Vacía en la Simulación.
20. Mensaje de Máximo Permitido
Sucede al momento de Simular y realizar una operación de conversión a Postfija (expresión

matemática) y esta supera 20 operadores.
21. Mensaje de Lectura
Surge cuando en una Lectura de la Simulación se esperaba un entero como entrada y no se dio tal
tipo de dato.
22. Mensaje de Lectura
Emerge cuando en una Lectura de la Simulación se esperaba un flotante como entrada y no se dio
tal tipo de dato.
70 de 75
Glosario
Compilador
Programa que se encarga de revisar si un Programa (Programa Fuente) de una Computadora,

Codificado (escrito) en un Determinado Lenguaje de Programación, esta libre de Errores. Si es así
nos proporciona en su Salida un Programa Objeto, que generalmente es la Traducción del
Programa Fuente a Código Ensamblador o bien Código Ejecutable. Para esto es necesario Cumplir
con cada una de las Fases de Compilación.
Fases de Compilación
Conceptualmente un Compilador opera en fases, cada una de las cuales Transforma al Programa
Fuente de una Representación a otra. Las cuales son:
1. Análisis Léxico
2. Análisis Sintáctico
3. Análisis Semántico
4. Generación de Código Intermedio
5. Optimización de Código
6. Generación de Código Ensamblador
7. Generación del Programa Objeto
En la Práctica se pueden agrupar algunas fases, y las Representaciones intermedias entre las
fases agrupadas no necesitan ser construidas explícitamente.
Análisis Léxico
Algoritmo que reconoce Tokens de a cuerdo a Expresiones Regulares, para cumplir con la primera
fase de un Compilador. Su principal función consiste en leer los caracteres de entrada y elaborar
como salida una secuencia de Componentes Léxicos que utiliza el Analizador Sintáctico para hacer
el Análisis Sintáctico. Para realizar Analizadores Léxicos se puede utilizar el PS1 creado por el Ing.
Francisco Ríos Acosta.
Análisis Sintáctico
Algoritmo que determina si un Código Fuente esta cumpliendo con las Reglas Sintácticas de un
Lenguaje, especificadas en la Gramática de dicho Lenguaje, cumpliendo con esto con la segunda
fase de un Compilador. Para realizar Analizadores Sintácticos se puede utilizar el E-Syntax creado
por Gerardo Emilio Veloz Flores.
Análisis Semántico
Es un Algoritmo que obtiene los Identificadores utilizados en el Código Fuente clasificándolos por el
tipo y asignándolos a una Tabla de Símbolos. Lo hace cumpliendo con lo siguientes requisitos:
1. Identificando los Símbolos no Declarados

2. Verificando la no Coincidencia de Tipos
3. Determinando la doble Declaración de Identificadores
Generación de Código Intermedio
Algoritmo que obtiene un Código entre el Código Fuente y el Ensamblador que permite definir
Datos, Estructuras de Control, Entrada y Salida de Datos. Ese Código se obtiene en base a una
71 de 75
Tabla de Equivalencias que define cada una de las Microinstrucciones que han de ser ejecutadas
por una Computadora.
72 de 75
Optimización de Código
Algoritmo que elimina instancias innecesarias para la elaboración del Código en Ensamblador, que
permitirá ejecutar la aplicación establecida en el Código Fuente.
Generación de Código Ensamblador
Algoritmo que obtiene el Código Ensamblador a partir del Código Intermedio, el cual puede ser
interpretado de manera directa por una Computadora. Este código se basa en la utilización de los
registros del CPU y las regiones de Segmentos del mismo.
Código Algory:
inicio
{
escribir("Hola");
}
fin
Código Ensamblador:
.model small
.stack
.data
Cadena1 DB 'Hola.$'
.code
programa:
mov ax, @data
mov ds, ax
mov dx, offset Cadena1
mov ah, 9
int 21h
end programa
Generación del Programa Objeto
Algoritmo que obtiene el Programa Objeto, que es un Programa a nivel de Lenguaje Máquina que
resulta de la compilación de un Programa Fuente.
Tokens ó Componentes Léxicos
Es una Instancia Individual de un Tipo de Símbolo que es representada por una Expresión Regular.
En pocas palabras representa un tipo de dato de un Código Fuente, es decir son Cadenas de
Caracteres que tienen un cierto Significado. Por Ejemplo:
X = 10;
Token Lexema
Identificador X
Operador de Asignación =
Número 10
Terminador de Instrucción ;
73 de 75
Expresión Regular
Notación que nos permite definir de Manera Precisa, al conjunto de Cadenas que forman el
Lenguaje representado por un Token. Por Ejemplo:
Letra -> [ a-zA-Z ]

Dig ->[ 0-9 ]
Sub ->_
Identificador -> Letra ( Letra | Dig | Sub ) * [ Â-Za-z0-9_ ]
74 de 75

Visual Algory

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Visual Algory

Cargado por

Copyright:

Formatos disponibles

Documentación Visual Algory

1. Iniciar con Visual Algory 2

2. Comenzar a Trabajar con Visual Algory 9

4. Mensajes de Error y Recuperación 65

Iniciar con Visual Algory

Historia de Visual Algory

Algory tiene sus inicios en la materia de Diseño Estructurado de Algoritmos de la carrera de

Referencia del Algory.h

#define INICIO_ALGORITMO void main(){

#define SALTAR_LINEA putchar('\n');

#define INICIO_ALGORITMO void main(){

#define DESDE for(

#define CRUZ_SIMPLE(a,b) gotoxy(a,b); \

#define CRUZ_DOBLE(a,b) gotoxy(a,b); \

#define LINEA_SIMPLE_H(a,b,c,d) gotoxy(a,b); putchar(195); for(i=a;i<c-1;i++) putchar (196); putchar(180);

#define LINEA_DOBLE_H(a,b,c,d) gotoxy(a,b); putchar(204); for(i=a+1;i<c;i++) putchar (205); putchar(185);

#define LINEA_SIMPLE_V(a,b,c,d) gotoxy(a,b); for(i=b;i<d;i++) {gotoxy(a,i); putchar (179);} gotoxy(a,i); putchar(193);

#define LINEA_DOBLE_V(a,b,c,d) gotoxy(a,b); for(i=b;i<d;i++) {gotoxy(a,i); putchar (186);} gotoxy(a,i); putchar(202);

#define CUADRO_SIMPLE(a,b,c,d) gotoxy(a,b); putchar(218); gotoxy(c,d); putchar(217); gotoxy(c,b); putchar(191);

#define CUADRO_DOBLE(a,b,c,d) gotoxy(a,b); putchar(201); gotoxy(c,d); putchar(188); gotoxy(c,b); putchar(187);

Iniciar con Visual Algory

Características y Limitaciones de Visual Algory

Visual Algory cuenta con la siguiente Interfase Gráfica:

Limitaciones de Visual Algory

Función Límite Máximo

Funcionamiento General de Visual Algory

Visual Algory opera de la siguiente forma:

Código Fuente (*.COD)

Obtención de la Tabla de Símbolos Tabla de Símbolos (*.TBS)

Obtención del Código Intermedio Código Intermedio (*.CIN)

Simulación del Código Intermedio

Comenzar a Trabajar con Visual Algory

¿Qué se puede hacer con Visual Algory?

Pasos para Simular un Código en Visual Algory

1. Cree un Nuevo Archivo de Código dando clic en el botón Nuevo .

3. De clic en el botón Compilar .

5. De clic en el botón Simular .

Pasos para Simular un Archivo de Simulación en Visual Algory

1. Abra un Archivo de Simulación dando clic en el botón Abrir y seleccione la Opción

2. De clic en el botón Simular .

El Aspecto de la Barra de Menús es el siguiente:

Esta dividida en 4 Menús los cuales son:

Nuevo: Crea un Nuevo Archivo de Código.

Abrir: Abre un Archivo de Código o una Simulación existente

Guardar: Guarda el Archivo de Código Activo, con su

Guardar como: Permite Guardar el Archivo de Código Activo

Vista Previa: Muestra una Vista Previa del Archivo de

Imprimir: Imprime el Archivo de Código Activo.

Propiedades de Impresión: Muestra el Diálogo "Configurar Impresión"; donde se puede

Cerrar: Cierra el Archivo de Código Activo.

Proyecto: Permite Compilar o Simular el Archivo de Código Activo.

Salir: Cierra la Aplicación.

Cortar: Quita la Selección del Archivo de Código Activo y la coloca

Copiar: Copia la Selección del Archivo de Código Activo al

Pegar: Inserta el Contenido del Portapapeles en el Punto de

Eliminar: Elimina la selección del Archivo de Código Activo.

Buscar: Busca el Texto Especificado en el Diálogo Buscar dentro

Reemplazar: Busca y Reemplaza el Texto Especificado en el

Ir a: Muestra la selección en la Línea especificada.

Seleccionar todo: Selecciona todo el Texto del Archivo de Código Activo.

Ventana de Análisis: Muestra u Oculta la Ventana de

Ventana de Errores: Muestra u Oculta la Ventana de Errores

Barra de Herramientas Estándar: Muestra u Oculta la Barra