UNIVERSIDAD NACIONAL DE SAN ANTONIO ABAD DEL CUSCO

Facultad de Ingeniería Eléctrica, Electrónica, Informática y Mecánica

Escuela Profesional de Ingeniería Informática y de Sistemas

Tema:

“Informe de compilador para SQL en ESPAÑOL”

Asignatura:

Construcción de compiladores

Tutor:

Ing. Soncco Álvarez, José Luis

Presentado por:

Quispe Soto, William Código: 124203

Salce Mejía, Nohemí Código: 951304

Cusco - Perú
2020
 i

INTRODUCCIÓN

Un compilador es un programa que lee un programa escrito en una lenguaje, el

lenguaje fuente, y lo traduce a un programa equivalente en otro lenguaje, el lenguaje objeto.

Como parte importante de este proceso de traducción, el compilador informa a el usuario de

la presencia de errores en el programa fuente.

La propuesta de implementación de un compilador para SQL en ESPAÑOL,

constituye tres fases de análisis: Análisis léxico, cada cadena de caracteres del programa

fuente se lee de izquierda a derecha y se agrupa en componentes léxicos, que son secuencias

de caracteres que tienen un significado colectivo; análisis sintáctico, los caracteres son

agrupados jerárquicamente en colecciones anidadas con un significado colectivo utilizando

reglas recursivas y finalmente el análisis semántico, se realizan revisiones para asegurar que

los componentes del programa no tenga errores semánticos.

En esta etapa del proyecto no centramos en la construcción de un analizador léxico.

Para toda la etapa de desarrollo utilizamos dos herramientas de trabajo, nuestra herramienta

generadora de analizadores léxicos flex, que, recibirá una especificación de patrones y

acciones para generar código en C que pueda ser compilado y obtener un ejecutable y bison

genera nuestro analizador sintáctico o parser que también genera código en c.

¿Por qué se usan expresiones regulares para el analizador léxico y gramáticas libre de

contexto para el analizador sintáctico?

Las expresiones regulares son una forma de especificar los patrones o reglas, estos

patrones son una forma de describir cada cadena de caracteres queriendo decir que es una

forma de definir los tokens o componentes léxicos, cada patrón concuerda con una serie de

cadenas.

Las gramáticas libres de contexto se utilizan para describir la sintaxis del lenguaje de

forma precisa y fácil de comprender, estas son reconocidos por los analizadores sintácticos.
 ii

ÍNDCE
INTRODUCCIÓN..................................................................................................i

INDICE DE TABLAS...............................................................................................................iv

1: ANALIZADOR LÉXICO.................................................................................5

1.1 CONSTRUYA UNA TABLA QUE INCLUYA EL LÉXICO DE SU LENGUAJE DE

PROGRAMCIÓN (1RA COLUMNA ES TIPO Y 2DA COLUMNA ES LISTA DE

PALABRAS).........................................................................................................................5

1.2 COLOQUE EL CÓDIGO FUENTE DEL ANALIZADOR LÉXICO (EN FLEX Y EN C)6

1.2.1 Analizador léxico en FLEX..........................................................................................6

1.2.2 Analizador léxico en C.................................................................................................8

2: ANALIZADOR SINTÁCTICO........................................................................9

2.1 DISEÑAR LAS GRAM´TICAS LILBRES DE COCNTEXTO PARA CADA UNA DE

LAS CONSTRUCCIONES DE SU LENGUAJE DE PROGRAMACIÓN.COLOCAR 4

EJEMPLOS DE CADA CONSTRUCCIÓN.........................................................................9

2.2 COLOQUE EL CÓDIGO FUENTE DEL ANALIZADOR SINTÁCTICO EN (BISON Y

C) 9

2.2.1 Analizador sintáctico en BISON..................................................................................9

2.2.2 Analizador sintáctico en C..........................................................................................10

3: TRATAMIENTO DE ERRORES..................................................................11

3.1. ANALIZADOR LÉXICO DEBE INFORMAR DE ERRORES CUANDO SEAN

ENCONTRADOS. IMPLEMENTAR UNA REGLA QUE PERMITA MOSTRAR UN

MENSAJE DE ERROR CUANDO SE ENCUENTRE UNA PALABRA NO

RECONOCIDA...................................................................................................................11

3.2 EL ANALIZADOR SINTÁCTICO DEBE INFORMAR DE ERRORES CUANDO SEAN

ENCONTRADOS, PARA TAL EFECTO SE DEBE CONSTRUIR POR LO MENOS 5

 iii

GRAMÁTICAS QUE DETECTEN ERRORES Y MUESTREN MENSAJES DE ERROR

ESPECIALIZADOS. DESCRIBIR EN EL INFORME CUALES SON LOS ERRORES Y

SUS RESPECTIVAS GRAMÁTICAS...............................................................................11

CONCLUSIONES................................................................................................12

RECOMENDACIONES......................................................................................13

REFERENCIAS...................................................................................................14
 iv

INDICE DE TABLAS

Tabla 1. Léxico de SQL en español................................................................................5

 5

1: ANALIZADOR LÉXICO

1.1 CONSTRUYA UNA TABLA QUE INCLUYA EL LÉXICO DE SU LENGUAJE DE

PROGRAMCIÓN (1RA COLUMNA ES TIPO Y 2DA COLUMNA ES LISTA DE

PALABRAS).

Tabla 1. Léxico de SQL en español

Tipo Lista de palabras

INICIADOR usar, ir, de, y, o, en
PALABRARESERVADA crear, insertar, alterar, eliminar, seleccionar
basedatos, tabla, procedimiento función, disparador,
ESTRUCTURA
valores
TIPODATOA numerico, texto, real
TIPODATOB datofecha, entero
OPERADOR <, >, < >, =>. <=, = y, o, de
INDICADOR [1-9]+[0-9]*, [1-9]+[0-9]*[,][1-9]+[0-9]*
VARIABLE [A-Za-z0-9]+
DIRECCIONADOR “.” , “ @”
DELIMITADOR “/*” “ */” “—“ “,” “(“ “)”

1.2 COLOQUE EL CÓDIGO FUENTE DEL ANALIZADOR LÉXICO (EN FLEX Y EN

C)
 6

1.2.1 Analizador léxico en FLEX

/* Programa lexer que será llamado para analizar la sintaxis de SQL server en Español */

/* Sección DEFINICIONES */
%{
#include <stdio.h>
#include "parser.tab.h" //para que lexer.l y parser.y usen las mismas constantes

#define BUSCAR 0
int estado;
int agregar_palabra(int tipo, char *palabra);
int buscar_palabra(char *palabra);
%}
/* TOKENS */

/* Palabras que son iniciadores */

INICIADOR (usar|ir|de||y|o|en)

/* Palabras reservadas */
PALABRARESERVADA (crear|insertar|alterar|eliminar)

/* Tipos de estructuras */
ESTRUCTURA (basedatos|tabla|procedimiento|funcion|disparador)

/* Tipo de datos */
TIPODATOA (numerico|texto|real)
TIPODATOB (datofecha|entero)

/* Operadores */
OPERADOR ("<"|">"|"<>"|"=>"|"<="|"="|y|o|de)

/* Indicador de numero */
INDICADOR [1-9]+[0-9]*|[1-9]+[0-9]*[,][1-9]+[0-9]*

/* Definicion de variable */
VARIABLE [A-Za-z0-9]+

/* Direccionador */
DIRECCIONADOR ("."|"@")

/* Delimitadores */
DELIMITADOR ("/*"|"*/"|"--"|","|"("|")")

/* Sección REGLAS */
%%
\n {estado = BUSCAR;} /*retornar a estado default*/

{INICIADOR} {/*procesar numero*/

agregar_palabra(1, yytext);
printf("%s :inicio de instrucciones\n", yytext); return INICIADOR;

}/*fin procesar numero*/

{PALABRARESERVADA} {/*procesar Reservada*/
agregar_palabra(2, yytext);
printf("%s :es una palabra reservada\n", yytext); return PALABRARESERVADA;
}/*fin procesar Reservada*/
{ESTRUCTURA} {/*procesar Variable*/
agregar_palabra(3, yytext);
printf("%s :es una estructura\n", yytext); return ESTRUCTURA;
}/*fin procesar Variable*/
 7

{TIPODATOA} {/*procesar Operador*/

agregar_palabra(4, yytext);
printf("%s :es un tipo de dato\n", yytext); return TIPODATOA;
}/*fin procesar Operador*/
{TIPODATOB} {/*procesar Operador*/
agregar_palabra(5, yytext);
printf("%s :es un tipo de dato\n", yytext); return TIPODATOB;
}/*fin procesar Operador*/
{OPERADOR} {/*procesar Delimitador*/
agregar_palabra(6, yytext);
printf("%s :es un operador\n", yytext); return OPERADOR;
}/*fin procesar Delimitsador*/
{INDICADOR} {/*procesar Comentario*/
agregar_palabra(7, yytext);
printf("%s :es un indicador\n", yytext); return INDICADOR;
}/*fin procesar Comentario*/
{VARIABLE} {/*procesar Comentario*/
agregar_palabra(8, yytext);
printf("%s :es una variable\n", yytext); return VARIABLE;
}/*fin procesar Comentario*/
{DIRECCIONADOR} {/*procesar Comentario*/
agregar_palabra(9, yytext);
printf("%s :es un direccionador\n", yytext); return DIRECCIONADOR;
}/*fin procesar Comentario*/
{DELIMITADOR} {/*procesar Comentario*/
agregar_palabra(10, yytext);
printf("%s :es un delimitador\n", yytext); return DELIMITADOR;
}/*fin procesar Comentario*/

. /*ignorar cualquier otro símbolo*/

%%

/* Sección CODIGO USUARIO */

/* definir una lista enlazada de palabras y tipos*/
struct palabra {
char *nombre_palabra;
int tipo_palabra;
struct palabra *sgte;
};

struct palabra *lista = NULL; /*primer elemento de la lista*/

int agregar_palabra(int tipo, char *palabra) {

struct palabra *p; /*entrada de la lista*/

if ( buscar_palabra(palabra) != BUSCAR ) {
/*printf("La palabra %s ya fue definida!!!\n", palabra);*/
return 0; //no funciono
}

/* asignar espacio de memoria */

p = malloc( sizeof( struct palabra ) );
p->nombre_palabra = malloc( strlen(palabra) + 1 );
/* copiar datos de palabra */
strcpy( p->nombre_palabra, palabra );
p->tipo_palabra = tipo;
/* enlazar nueva entrada a lista */
p->sgte = lista;
lista = p;
return 1; //funciono
 8

int buscar_palabra(char *palabra){

struct palabra *p = lista;

/* buscar palabra en la lista */

while (p != NULL) {
if ( strcmp(p->nombre_palabra, palabra) == 0 )
return p->tipo_palabra;
p = p->sgte;
}

return BUSCAR; /*no encontrado*/

}

2: ANALIZADOR SINTÁCTICO

2.1 DISEÑAR LAS GRAM´TICAS LILBRES DE COCNTEXTO PARA CADA UNA DE

LAS CONSTRUCCIONES DE SU LENGUAJE DE PROGRAMACIÓN.COLOCAR 4

EJEMPLOS DE CADA CONSTRUCCIÓN

 9

sentencia: PALABRARESERVADA ESTRUCTURA VARIABLE

crear basedatos bdBiblioteca
eliminar basedatos bdBiblioteca
eliminar procedimiento crearsecuencia
eliminar tabla Persona

sentencia: INICIADOR VARIABLE INICIADOR

usar bdBiblioteca ir
sentencia: PALABRARESERVADA ESTRUCTURA INICIADOR VARIABLE
seleccionar * de Persona

2.2 COLOQUE EL CÓDIGO FUENTE DEL ANALIZADOR SINTÁCTICO EN (BISON

Y C)
 10

2.2.1 Analizador sintáctico en BISON

%{
#include <stdio.h>
int yylex();
int yyerror(char *s);

%}
%token INICIADOR PALABRARESERVADA ESTRUCTURA TIPODATOA TIPODATOB OPERADOR INDICADOR
VARIABLE DIRECCIONADOR DELIMITADOR
%%
sentencias: sentencia sentencias|sentencia;

/*sentencia para crear una base de datos*/

sentencia: PALABRARESERVADA ESTRUCTURA VARIABLE INICIADOR {printf("Sentencia valida para crear una base de
datos\n");};

/*sentencia para usar una base de datos*/

sentencia: INICIADOR VARIABLE INICIADOR {printf("Sentencia valida para usar una base de datos\n");};

/*setencia para la operacion seleccionar*/

sentencia: PALABRARESERVADA VARIABLE INICIADOR VARIABLE {printf("Sentencia valida de seleccionar\n");};

/*sentencia para crear una tabla*/

sentencia: INICIO DETALLES FIN {printf("Sentencia valida de crear una tabla\n");};

INICIO: PALABRARESERVADA ESTRUCTURA VARIABLE DELIMITADOR;

DETALLES: DETALLE DETALLES|DETALLE;
DETALLE: VARIABLE TIPODATOB;
DETALLE: VARIABLE TIPODATOA DELIMITADOR INDICADOR DELIMITADOR;
FIN: DELIMITADOR;

/*setencia para seleccionar de una tabla*/

sentencia: PALABRARESERVADA DIRECCIONADOR OPERADOR VARIABLE;

/*setencia para insertar en una tabla*/

sentencia: PALABRARESERVADA INICIADOR VARIABLE ESTRUCTURA DELIMITADOR parametro DELIMITADOR;

parametro: atributo DELIMITADOR atributo DELIMITADOR atributo DELIMITADOR atributo;

atributo: DELIMITADOR VARIABLE DELIMITADOR

%%

/* Sección CODIGO USUARIO */

FILE *yyin;
int main() {
do {
yyparse();
}
while ( !feof(yyin) );

return 0;
}

int yyerror(char *s) {

fprintf(stderr, "JS:%s\n", s);
return 0;
}
 11

3: TRATAMIENTO DE ERRORES

3.1. ANALIZADOR LÉXICO DEBE INFORMAR DE ERRORES CUANDO SEAN

ENCONTRADOS. IMPLEMENTAR UNA REGLA QUE PERMITA MOSTRAR UN

MENSAJE DE ERROR CUANDO SE ENCUENTRE UNA PALABRA NO

RECONOCIDA.

int agregar_palabra(int tipo, char *palabra) {

struct palabra *p; /*entrada de la lista*/

if ( buscar_palabra(palabra) != BUSCAR ) {
/*printf("La palabra %s ya fue definida!!!\n", palabra);*/
return 0; //no funciono
}

/* asignar espacio de memoria */

p = malloc( sizeof( struct palabra ) );
p->nombre_palabra = malloc( strlen(palabra) + 1 );
/* copiar datos de palabra */
strcpy( p->nombre_palabra, palabra );
p->tipo_palabra = tipo;
/* enlazar nueva entrada a lista */
p->sgte = lista;
lista = p;
return 1; //funciono

3.2 EL ANALIZADOR SINTÁCTICO DEBE INFORMAR DE ERRORES CUANDO

SEAN ENCONTRADOS, PARA TAL EFECTO SE DEBE CONSTRUIR POR LO

 12

MENOS 5 GRAMÁTICAS QUE DETECTEN ERRORES Y MUESTREN MENSAJES

DE ERROR ESPECIALIZADOS. DESCRIBIR EN EL INFORME CUALES SON

LOS ERRORES Y SUS RESPECTIVAS GRAMÁTICAS.

sentencia: PALABRARESERVADA ESTRUCTURA VARIABLE

crear basedatos crear
la VARIABLE crear es una PALABRARESERVADA no puede ser utilizada

eliminar basedato Tienda

basedato no se reconoce como ESTRUCTURA

iliminar procedimiento crearsecuencia

iliminar no es una PALABRARESERVADA

eliminar Tienda
falta definir ESTRUCTURA

crear basedatos Tienda

La VARIABLE Tienda ya existe
 13

CONCLUSIONES

 Se concluyó satisfactoriamente
 14

RECOMENDACIONES

 Se recomienda como base para el desarrollo del analizador tener conocimientos

básicos en flex y bison.