-1-

UNIVERSIDA INCA GARCILASO DE LA VEGA

Facultad de Ingeniera de Sistemas, Informtica y
Telecomunicaciones.

Asignatura de Lenguaje de Programacin II


Trabajo de un Sistema Gestor de Base de Datos


Profesor:
Lic. Carlos A. Ruiz De la Cruz Melo


Alumno
MUOZ SAGARVINAGA LEONIDAS



2009



















-2-
1. Introduccin:

Actualmente los lenguajes de programacin orientados a objetos se encuentran en todo
tipo de dispositivo electrnico. Prueba de ello son los mltiples equipos electrnicos que
usan este tipo de lenguaje. Debido a la versatilidad y eficiencia de la tecnologa, la
portabilidad de su plataforma y la seguridad que aporta, la han convertido en la
tecnologa ideal para su aplicacin a redes. De porttiles a centros de datos, de consolas
de juegos a sper equipos cientficos, de telfonos mviles a Internet, estn presentes
en casi todos los dispositivos.

Asimismo hasta la fecha, el paradigma de la programacin orientada a objetos ha atrado
a ms de 6,5 millones de desarrolladores de software. Se utiliza en los principales
sectores de la industria de todo el mundo y est presente en un gran nmero de
dispositivos, equipos y redes.

Un Sistema Gestor de datos (SGBD) es un conjunto de programas que permiten crear y
mantener una Base de Datos, asegurando su integridad, confidencialidad y seguridad.
Por tanto debe permitir:
Definir una base de datos: Especificar tipos, estructuras y restricciones de datos.
Construir la base de datos: Guardar los datos en algn medio controlador por el
mismo SGBD.
Manipular la base de datos: Realizar consultas, actualizarlas, generar informes.
Algunas de las caractersticas deseables en un Sistema Gestor de Base de Datos son:
Restricciones de los accesos no autorizados: Cada usuario ha de tener unos
permisos de acceso y autorizacin.
Cumplimiento de las restricciones de integridad: EL SGBD ha de ofrecer recursos
para definir y garantizar el cumplimiento de las restricciones de integridad.
El gestor de la base de datos es el interface con los programas de aplicacin y las
consultas de los usuarios. El gestor de la base de datos acepta consultas y examina los
esquemas externo y conceptual para determinar qu registros se requieren para
satisfacer la peticin. Entonces el gestor de la base de datos realiza una llamada al
gestor de ficheros para ejecutar la peticin.

Los principales componentes del gestor de la base de datos son los siguientes:

Control de autorizacin: Este mdulo comprueba que el usuario tiene los
permisos necesarios para llevar a cabo la operacin que solicita.
Procesador de comandos: Una vez que el sistema ha comprobado los permisos
del usuario, se pasa el control al procesador de comandos.
Control de la integridad: Cuando una operacin cambia los datos de la base de
datos, este mdulo debe comprobar que la operacin a realizar satisface todas
las restricciones de integridad necesarias.
Optimizador de consultas: Este mdulo determina la estrategia ptima para la
ejecucin de las consultas.
Gestor de transacciones: Este mdulo realiza el procesamiento de las
transacciones.
Planificador (Schedule): Este mdulo es el responsable de asegurar que las
operaciones que realicen concurrentemente sobre la base de datos tienen lugar
sin conflictos.
Gestor de recuperacin: Este mdulo garantiza que la base de datos permanece
en un consistente en caso de que se produzca algn fallo.
-3-
Gestor de buffers: Este mdulo es el responsable de transferir los datos entre
memoria principal y los dispositivos de almacenamiento secundario. A este
modulo tambin se le denomina gestor de datos.

Como parte del anlisis y diseo del aplicativo, se presenta el cdigo fuente y toma de
pantalla la cual es simulada en un escenario de laboratorio.

Objetivos:

PRIMERA PARTE:
Utilizando el SGBD se podr crear una base de datos.
Se podr crear tablas en la base de datos y sus respectivos campos.
Se podrn insertar registros en las tablas creadas y guardarlos en el disco en
forma de archivos.

SEGUNDA PARTE:
Se podr realizar consultas a la base de datos, tales como seleccin,
actualizacin y eliminacin.
Se podrn realizar operaciones de combinacin.



2. DEFINICION BREVE DE SGBD:

El proyecto se basa en un Sistema Gestor de Base de Datos controlado por una
interface. Una base de datos es una coleccin de datos clasificados y estructurados que
son guardados en uno o varios ficheros pero referenciados como si de un nico fichero
se tratara.

Los datos de una base de datos relacional se almacenan en tablas lgicamente
relacionadas entre si utilizando campos clave comunes. A su vez, cada tabla dispone los
datos en filas y columnas. Por ejemplo, piense en una lista de telfonos.

Los datos relativos a un telfono (nombre, direccin, telfono, etc.) son columnas que
agrupamos en una fila. El conjunto de todas las filas de todos los telfonos forman una
tabla de base de datos.



Nombre Direccion Telefono
Aguado Rodriguez, Jesus Las Ramblas 3, Barcelona 932345678
Cuesta Suer, Ana Maria Mayor 22, Madrid 918765432


Como se puede observar, una tabla es una base de datos presentada en forma de una
matriz bidimensional, donde las filas reciben tambin el nombre de filas o registros y las
columnas, de campos.

Los usuarios de un sistema administrador de base de datos pueden realizar operaciones
sobre una determinada base como insertar, recuperar, modificar y eliminar datos, asi
como aadir nuevas tablas o eliminarlas.





-4-
Tambin se hizo uso de herramientas tales como:

Analizador Sintctico es una de las partes de un compilador que transforma su entrada
en un rbol de derivacin.
El anlisis sintctico convierte el texto de entrada en otras estructuras (comnmente
rboles), que son ms tiles para el posterior anlisis y capturan la jerarqua implcita de
la entrada. Un analizador lxico crea tokens de una secuencia de caracteres de entrada
y son estos tokens los que son procesados por el analizador sintctico para construir la
estructura de datos, por ejemplo un rbol de anlisis o rboles de sintaxis abstracta.
El anlisis sintctico tambin es un estado inicial del anlisis de frases de lenguaje
natural. Es usado para generar diagramas de lenguajes que usan flexin gramatical,
como los idiomas romances o el latn. Los lenguajes habitualmente reconocidos por los
analizadores sintcticos son los lenguajes de libre contexto. Cabe notar que existe una
justificacin formal que establece que los lenguajes libres de contexto son aquellos
reconocibles por un autmata de pila de modo que todo analizador sintctico que
reconozca un lenguaje libre de contexto es equivalente en capacidad computacional a un
autmata de pila.
Analizador Semntico:
Se compone de un conjunto de rutinas independientes, llamadas por los analizadores
morfolgico y sintctico. El anlisis semntico utiliza como entrada el rbol sintctico
detectado por el anlisis sintctico para comprobar restricciones de tipo y otras
limitaciones semnticas y preparar la generacin de cdigo.
En compiladores de un solo paso, las llamadas a las rutinas semnticas se realizan
directamente desde el analizador sintctico y son dichas rutinas las que llaman al
generador de cdigo. El instrumento ms utilizado para conseguirlo es la gramtica de
atributos.
En compiladores de dos o ms pasos, el anlisis semntico se realiza
independientemente de la generacin de cdigo, pasndose informacin a travs de un
archivo intermedio, que normalmente contiene informacin sobre el rbol sintctico en
forma linealizada (para facilitar su manejo y hacer posible su almacenamiento en
memoria auxiliar). En cualquier caso, las rutinas semnticas suelen hacer uso de una
pila (la pila semntica) que contiene la informacin semntica asociada a los operandos
(y a veces a los operadores) en forma de registros semnticos.
El lenguaje permitir:

1) Crear una base de datos.
2) Crear tablas en la base de datos.
3) Escribir datos en la tabla.
4) Modificar datos en la tabla.
5) Borrar registros de una tabla.
6) Seleccionar datos de una tabla.
7) Combinaciones entre tablas.






-5-
3. DESCRIPCIN DEL LENGUAJE:

PALABRAS RESERVADAS:
Estn compuestas solo por letras. Tienen un significado especial y no se pueden utilizar
para otros propsitos. Una palabra reservada no se puede utilizar como identificadora.
La siguiente es la lista de las palabras reservadas de nuestro lenguaje.

1. entero
2. real
3. cadena
4. CREAR
5. TABLA
6. INSERTAR
7. EN
8. VALORES
9. ACTUALIZAR
10. PONER
11. DONDE
12. ELIMINAR
13. DE
14. SELECCIONAR
15. CLAVE
16. TODO


3.1. Estructura del programa:

3.1.1.- Creacin de una Tabla

CREAR TABLA <nom_tabla>
(
<campo1> <tipo_dato>,
<campo2> <tipo_dato>,
<campo3> <tipo_dato>,
.
.
.
<campo_n> <tipo_dato>;
CLAVE ( <nom_campo> )
)

3.1.2.- Insertar datos en la Tabla

INSERTAR EN <nom_tabla>
VALORES (
<Valor1>,
<Valor2>,
.
.
.
<Valor_n>
)




-6-
3.1.3.- Modificar datos de una tabla

ACTUALIZAR <nom_tabla>
PONER (
nom_campo1 = valor1,
nom_campo2 = valor2,
.
.
.
nom_campo_n = valor_n

)
DONDE (
nom_campo1 op_relacional1 valor1
nom_campo2 op_relacional2 valor2
.
.
.
nom_campo_n op_relacional_n valor_n
)

3.1.4.- Eliminar una Tabla

ELIMINAR DE <nom_tabla>
DONDE (
nom_campo1 op_relacional1 valor1
)

3.1.5.- Seleccionar datos de una Tabla

SELECCIONAR
(
nom_campo1
nom_campo2
.
.
.
nom_campo_n
) DE nom_tabla DONDE ( condiciones )


















-7-
3.2. EXPRESIONES:

Operadores Relacionales:

< Menor que
<= Menor igual que
> Mayor que
>= Mayor igual que
< > Diferente
= = Igualdad

Operadores Lgicos:

& Conjuncin.
| Disyuncin.

Operadores Delimitadores:

; Indica la finalizacin de una lnea de instruccin.
( Indica el inicio de lo se va a ingresar en el comando
escribir o leer
) Indica el fin de lo se va a ingresar en el comando
escribir o leer
, Separador
Indica el comienzo de una constante cadena

Operadores de Asignacin:

= Indica asignacin




4. OTROS ELEMENTOS DEL LENGUAJE:

Identificador: Estn compuestos solo por letras y dgitos. Tenemos como identificadores
a los nombres de las tablas y de los campos que sern creados por el usuario.

Todo identificador debe empezar con una letra, y puede ser seguido de nmeros, mas no
puede empezar con nmeros. A los identificadores se les asigna valores a lo largo del
programa, utilizndolos para guardar cantidades o cadenas que pueden ser
modificables.

Constantes: Los valores respectivamente que se le asignan a los campos de un
determinado registro de una tabla.










-8-
5. GRAMATICA DEL LENGUAJE

<CREATE> -> CREAR TABLA <nom_tabla> ( <campos> ;
<clave> )
<nom_tabla> -> Idenetificador
<clave> -> CLAVE ( <nom_campo> )
<campos> -> <nom_campo> <tipo_campo>
<mas_campos>
<mas_campos> -> ,<campos>
<mas_campos> -> vacio
<nom_campo> -> identificador
<clave> -> CLAVE (<nom_campo>)
<tipo_campo> -> entero
<tipo_campo> -> real
<tipo_campo> -> cadena


<INSERT> -> INSERTAR EN <nom_tabla> VALORES
(<valores>)
<valores> -> <valor> <mas_balores>
<mas_valores> -> ,<valores>
<mas_valores> -> vacio
<valor> -> num_real
<valor> -> num_entero
<valor> -> cad_car


<UPDATE> -> ACTUALIZAR <nom_tabla> PONER
(<asignacion>)
DONDE ( <condiciones> )
<asignacion> -> <nom_campo> = <valor> <mas_asignaciones>
<mas_asignaciones> -> ,<asignacion>
<mas_asignaciones> -> vacio
<condiciones> -> <nom_campo> <op_relacional> <dato>
<mas_condiciones>
<mas_condiciones> -> <op_logico> <condiciones>
<mas_condiciones> -> vacio
<op_logico> -> |
<op_logico> -> &
<op_relacional> -> < / > / <= / >= / == / <>


<DELETE> -> ELIMINAR DE <nom_tabla> DONDE
(<condiciones>)


<SELECT> -> SELECCIONAR ( <lista_campos> ) DE
<nom_tabla> DONDE ( <condiciones>)
<lista_campos> -> TODO
<lista_campos> -> <nom_campo> <mas_campos>
<mas_campos> -> , <nom_campo> <mas_campos>
<mas_campos> -> vacio




-9-
6. DEFINCION DEL PROYECTO:

La aplicacin que a continuacin ser explicada, consiste en una aplicacin donde
podremos guardar en una base de datos toda la informacin necesaria que necesita
una empresa sobre sus empleados; aadir, mostrar, guardar y leer.
Utilizaremos el lenguaje Java, con IDE NetBeans, utilizamos analizadores lxicos,
sintcticos y semnticos.

6.1 Analizador Lxico:

La entrada del analizador lxico podemos definirla como una secuencia de caracteres.












Donde la gramtica (N, T, P, S) tenemos,

N: Smbolos no terminales
T: Smbolos terminales
P: Reglas de Produccin
S: Smbolo distinguido (Axioma inicial)

El analizador lxico tiene que dividir la secuencia de caracteres en palabras con
significado propio y despus convertirlo a una secuencia de terminales desde el punto
de vista del analizador sintctico, que es la entrada del analizador sintctico.

El analizador lxico reconoce las palabras en funcin de una gramtica regular de
manera que sus NO TERMINALES se convierten en los elementos de entrada de
fases posteriores.

En el caso de nuestro lenguaje llamado Friendly buscamos aprender un poco ms
acerca de lo que son y como se generan los lenguajes, en esta primera parte del
proyecto presentamos lo referente al Lexico del lenguaje, por ende empezaremos
denotando aquellas expresiones propias de nuestro lenaguaje.

6.2 Analizador Sintctico:

Se puede construir un analizador sintctico descendente predictivo no recursivo sin
llamadas recursivas a procedimientos, sino que se utiliza una pila auxiliar de smbolos
terminales y no terminales. Para determinar qu produccin debe aplicarse en cada
momento se busca en una tabla de anlisis sintctico (parsing table) en funcin del
smbolo de pre-anlisis que se est observando en ese momento y del smbolo en la
cima de la pila se decide la accin a realizar.





rbol
Sintctico
Secuencia de
Terminales
Secuencia de
Caracteres
LEXICO SINTCTICO
Usa una gramtica
( N, T, P, S )
-10-


Esquema de un analizador sintctico descendente dirigido por tabla






Buffer de entrada: que contiene la cadena de componentes lxicos que se va
analizar seguida del smbolo $ de fin de cadena.
La pila de anlisis sintctico: que contiene una secuencia de smbolos de la
gramtica con el smbolo $ en la parte de abajo que indica la base de la pila.
Una tabla de anlisis sintctico: que es una matriz bidimensional M[X,a] con X
Vn y a Vt U { $ }. La tabla de anlisis sintctico dirige el anlisis y es lo
nico que cambia de un analizador a otro (de una gramtica a otra).
Salida: la serie de producciones utilizadas en el anlisis de la secuencia de
entrada.
El analizador sintctico tiene en cuenta en cada momento, el smbolo de la cima de la
pila X y el smbolo en curso de la cadena de entrada a (el smbolo de pre anlisis).
Estos dos smbolos determinan la accin a realizar, que pueden ser:
Si X == a == $, el anlisis sintctico ha llegado al final y la cadena ha sido
reconocida con xito.
Si X == a $, el terminal se desapila (se ha reconocido ese terminal) y se
avanza en la entrada obteniendo el siguiente componente lxico.
Si X es no terminal, entonces se consulta en la tabla M[X,a]. La tabla contiene
una produccin a aplicar o si esta vaca significa un error. Si es una produccin
de la forma X Y1Y2Yn, entonces se meten los smbolos Yn Y1 en la
pila (notar el orden inverso). Si es un error el analizador llama a una rutina de
error.
Las acciones semnticas insertadas en las producciones de la gramtica se pueden
considerar como si fueran smbolos adiciones y que tienen asociado un procedimiento
a ejecutar (smbolos de acciones). Las llamadas a rutinas semnticas no se les pasa
parmetros explcitos, los parmetros necesarios se pueden transmitir a travs de una
pila semntica.

-11-
Tabla de Primeros y Siguientes:

Lo siguiente es parte del anlisis sintctico, se obtiene los primeros elementos de cada
no terminal, el siguiente paso consiste en obtener los elementos que siguen
inmediatamente a cada una de las producciones, conocidos como los Siguientes:


SIMBOLOS PRIMEROS SIGUIENTES
CREATE CREAR
DELETE ELIMINAR
IN ACTUALIZAR, CREAR, ELMINAR, INSERTAR,
SELECCIONAR

nom_campo Identificador
asignacin Identificador )
campos Identificador ;
clave CLAVE
condiciones Identificador )
lista_campos TODO identificador )
mas_asignacion , , # )
mas_campos , , # ;
op_logica & , I
mas_condiciones & , I , # )
mas_valores , , # )
nom_campos , , # )
nom_tabla identificador
op_relacional < , <= , <> , == , > , >=
tipo_campo cadena , entero , real
valor cad_car , num_entero , num_real
valores cad_car , num_entero , num_real


*El TAS generado se encuentra adjunto en la carpeta del proyecto con el nombre de
nueva tabla (formato de Excel)






















-12-
7. DESCRIPCION DEL CODIGO FUENTE:

7.1. Descripcin de las clases por paquetes:





7.1.1 Analizador lxico:






-13-
1. Clase: Etiqueta.- En esta clase describimos cada una de las Etiquetas que
emplearemos, as como tambin le asignaremos un valor.

2. Clase: TablaDeSimbolos.- Utilizamos esta clase para poder hacer un uso
adecuado de los tokens.

3. Clase: Token.- Nos permite describir un token, adems podemos utilizar los
atributos de cada token.

4. Clase: Analizador Lexico.- En esta clase creamos las palabras reservadas;
borramos los espacios en blanco as como los tabuladores; luego verificamos
los dgitos y caracteres permitidos; por ltimo Escanea el codigo fuente y
retorna objetos de tipo Token cada vez que encuentra un lexema conocido,
para esto nos ayudaremos de un autmata.

5. Clase: TestLexico.- Con esta clase leeremos una cadena de caracteres, para
luego comparar con la tabla de smbolos.
La clase Analizador Lexico tiene como uno de sus mtodos el mtodo escanear()
retorna un objeto de la clase Token y representa el autmata que reconoce todos
los elementos del alfabeto:

// Escanea el codigo fuente y retorna objetos de tipo Token cada
// vez que
// que encuentra un lexema conocido
public Token escanear() {
int estado = 0; // estado del automata
char car; // alamcena el caracter escaneado
buffer = ""; // limpiamos el buffer

for (;;) {
// obtenemos el caracter de la posicion: index
car = codigo_fuente.charAt(index);
//System.out.println("\t estado = "+estado+" car = "+car);

if (car != '$') {
switch (estado) {
case 0:
buffer = buffer + car;
if (car == ' ') {
estado = 0;
} else {
if (car == '<') {
estado = 1;
} else {
if (car == '=') {
estado = 5;
} else {
if (car == '>') {
-14-
estado = 8;
} else {
if (Character.isLetter(car)) {
estado = 11;
} else {
if (Character.isDigit(car)) {
estado = 13;
} else {
if (car == ',') {
estado = 17;
} else {
if (car == ';') {
estado = 18;
} else {
if (car == ')') {
estado = 19;
} else {
if (car == '(') {
estado = 20;
} else {
if (car == '\"') {
estado = 21;
} else {
if (car == '|')
{
estado = 22;
} else {
if (car ==
'&') {
estado =
23;
} else {
return new
Token(Etiqueta.ERROR, "ERROR", "Caracter " + car + " invalido");
}
}
}
}
}
}
}
}
}
}
}
}
}
break;
-15-

case 1:
if (car == '=') {
// agregamos el carcatrer leido
buffer = buffer + car;
estado = 2;
} else {
if (car == '>') {
buffer = buffer + car;
estado = 3;
} else {
if (caracterPermitido(car)) {
// si el carcter analizado es un carcter
vlido para nuestro lenguaje
index = index - 1; // retroceder
posicion
estado = 4;
} else {
if (car == ' ') {
estado = 4;
} else {
return new Token(Etiqueta.ERROR,
"ERROR", "Caracter " + car + " invalido"); // ERROR: caracter no
valido
}
}
}
}
break;

case 2:
return new Token(Etiqueta.OP_RELACIONAL,
"Op_Relacional", "<=");
case 3:
return new Token(Etiqueta.OP_RELACIONAL,
"Op_Relacional", "<>");
case 4:
return new Token(Etiqueta.OP_RELACIONAL,
"Op_Relacional", "<");

case 5:
if (car == '=') {
buffer = buffer + car;
estado = 6;
} else {
if (caracterPermitido(car)) {
index = index - 1; // retroceder poscion
estado = 7;
-16-
} else {
if (car == ' ') {
estado = 7;
} else {
return new Token(Etiqueta.ERROR,
"ERROR", "Caracter " + car + " invalido"); // ERROR: caracter no
valido
}
}
}
break;

case 6:
return new Token(Etiqueta.OP_RELACIONAL,
"Op_Relacional", "==");
case 7:
return new Token(Etiqueta.OP_ASIGNACION,
"Op_Asignacion", "=");

case 8:
if (car == '=') {
buffer = buffer + car;
estado = 9;
} else {
if (caracterPermitido(car)) {
index = index - 1;
estado = 10;
} else {
if (car == ' ') {
estado = 10;
} else {
return new Token(Etiqueta.ERROR,
"ERROR", "Caracter " + car + " invalido"); // ERROR: caracter no
valido
}
}
}
break;

case 9:
return new Token(Etiqueta.OP_RELACIONAL,
"Op_Relacional", ">=");
case 10:
return new Token(Etiqueta.OP_RELACIONAL,
"Op_Relacional", ">");

case 11:
if (Character.isLetter(car)) {
-17-
buffer = buffer + car;
estado = 11;
} else {
if (caracterPermitido(car)) {
index = index - 1;
estado = 12;
} else {
if (car == ' ') {
estado = 12;
} else {
return new Token(Etiqueta.ERROR,
"ERROR", "Caracter " + car + " invalido"); // ERROR: caracter no
valido
}
}
}
break;

case 12:
Token p = (Token)
tabla_simb.obtener(buffer.trim());
if (p == null) {
p = new Token(Etiqueta.IDENTIFICADOR,
"identificador", buffer.trim());
tabla_simb.poner(p);
return p;
} else {
return p;
}

case 13:
if (Character.isDigit(car)) {
buffer = buffer + car;
estado = 13;
} else {
if (car == '.') {
buffer = buffer + car;
estado = 15;
} else {
if (caracterPermitido(car)) {
index = index - 1;
estado = 14;
} else {
if (car == ' ') {
estado = 14;
} else {
-18-
return new Token(Etiqueta.ERROR,
"ERROR", "Caracter " + car + " invalido"); // ERROR: caracter no
valido
}
}
}
}
break;

case 14:
return new Token(Etiqueta.NUM_ENTERO,
"num_entero", buffer.trim());

case 15:
if (Character.isDigit(car)) {
buffer = buffer + car;
estado = 15;
} else {
if (caracterPermitido(car)) {
index = index - 1;
estado = 16;
} else {
if (car == ' ') {
estado = 16;
} else {
return new Token(Etiqueta.ERROR,
"ERROR", "Caracter " + car + " invalido"); // ERROR: caracter no
valido
}
}
}
break;

case 16:
return new Token(Etiqueta.NUM_ENTERO, "num_real",
buffer.trim());

case 17:
return new Token(Etiqueta.SEPARADOR, "separador",
",");
case 18:
return new Token(Etiqueta.SEPARADOR, "separador",
";");
case 19:
return new Token(Etiqueta.SEPARADOR, "separador",
")");
case 20:
-19-
return new Token(Etiqueta.SEPARADOR, "separador",
"(");

case 21:
int a = codigo_fuente.indexOf('\"'); // primera
ocurrencia de '\"'
int b = codigo_fuente.lastIndexOf('\"'); //
ultima ocurrencia de '\"'
if (a != b && a + 1 != b) { //
buffer = buffer + car;
estado = 24;
} else {
return new Token(Etiqueta.ERROR, "ERROR",
"Cadena vacia"); // ERROR: caracter no valido
}
break;

case 22:
return new Token(Etiqueta.OP_LOGICO, "op_logico",
"|");
case 23:
return new Token(Etiqueta.OP_LOGICO, "op_logico",
"&");

case 24:
buffer = buffer + car;
if (car != '\"') {
if (caracterPermitido(car) || car == ' ') {
estado = 24;
} else {
return new Token(Etiqueta.ERROR, "ERROR",
"Caracter " + car + " invalido"); // ERROR: caracter no valido
}
} else {
index++; // porque en el estado 0 no hay
opcion para a entrada '\"'
return new Token(Etiqueta.CADENA, "cad_car",
buffer);
}
break;
}
index++;
} else {
return new Token(Etiqueta.FIN, "FIN", "$");
}
}

}
-20-
AUTOMATA DEL METODO SCANNEAR:

















































-21-

7.1.2 Analizador Sintctico:





Clase TablaAnalisisSintactico:

Esta clase nos construir el TAS (Tabla de Anlisis Sintctico) ya que especificamos el
valor de cada celda.

La clase contiene los siguientes atributos: String M[], int nFILA, int nCOLUMNA y
String produccion.

Esta clase contiene los siguientes metodos:
public boolean esTerminal (String car) : Este mtodo nos indicar si el dato de
tipo String que ser pasado por parmetro es un terminal o no.
public String RetProduccion() : Este mtodo nos retornara la variable
produccion.
boolean ExisteInterseccion( String xx, String ae): Este mtodo nos indicar si
existe una especie de relacin entre el terminal y el no terminal ingresados por
parmetro.

Dentro de la clase AnalizadorSintactico se encuentra el mtodo void sintctico que se
encarga de verificar que la secuencia de tokens pertenezcan a una sintaxis aceptada
por el lenguaje.




-22-
public void sintactico() {
Token token=null;
String ultimoPila;
boolean seguir = true;
boolean nuevoToken = true;
String produccion;
String t0ken="";
int etiqueta;
//listaTokens.removeAll(listaTokens);

do {
if (nuevoToken) {
token = aLexico.escanear();
listaTokens.add(token);
etiqueta = token.etiqueta();

if (etiqueta == Etiqueta.PALABRA_RESERVADA || etiqueta ==
Etiqueta.OP_RELACIONAL
|| etiqueta == Etiqueta.OP_ASIGNACION || etiqueta
== Etiqueta.OP_LOGICO
|| etiqueta == Etiqueta.SEPARADOR || etiqueta ==
Etiqueta.FIN) {
t0ken = token.lexema();
} else {
t0ken = token.tipo();
}
}

//System.out.println("token: "+t0ken);

ultimoPila = pila.get(pila.size() - 1);

if ((token.etiqueta() != Etiqueta.ERROR)) {

if (tas.esTerminal(ultimoPila)) {
if (t0ken.equals(ultimoPila)) {
//System.out.println("| " + verPila() + " | " +
t0ken + " | " + " -- ");
pila.remove(pila.size() - 1);
nuevoToken = true;
} else {
//System.out.println("Error Sintactico1: en
"+token.lexema()+" es "+token.tipo());
//System.out.println("Error Sintactico1: antes de
"+token.lexema()+" que es un "+token.tipo()+
// " Se necesita "+ultimoPila);
listaTokens.add(new Token(Etiqueta.ERROR, "ERROR",
"Caracter " +
"Error Sintactico1: antes de
"+token.lexema()+" que es un "+token.tipo()+
" Se necesita "+ultimoPila));
seguir = false;
}
} else {
if (tas.ExisteInterseccion(ultimoPila, t0ken)) {
-23-
produccion = tas.RetProduccion();
//System.out.println("| " + verPila() + " | " +
t0ken + " | " + ultimoPila + "->" + produccion);
pila.remove(pila.size() - 1);

nuevoToken = false;
if (!produccion.equals("#")) {
Empilar(produccion);
}

}else{
// System.out.println("Error Sintactico2: antes de
"+token.lexema()+" que es un "+token.tipo()+
// " Se necesita "+ultimoPila);
listaTokens.add(new Token(Etiqueta.ERROR, "ERROR",
"Caracter " +
"Error Sintactico1: antes de
"+token.lexema()+" que es un "+token.tipo()+
" Se necesita "+ultimoPila));
seguir = false;
}
}
} else {
// ERROR LEXICO
System.out.println("Error Lexico: "+token.lexema());
seguir = false;
}

} while (!ultimoPila.equals("$") && seguir);
}

























-24-
7.1.3 Ejecucin de cdigo:

Este paquete contiene las clases que se encargan de verificar que las instrucciones
ingresadas estn semnticamente correctas. Entre otras funciones verifica que los
tipos de datos declarados correspondan con los tipos de datos ingresados. Tambin
se encarga de verificar que los nombres de tablas y campos estn correctamente
declarados para poder ser utilizados como parmetros para crear y usar las tablas y
por ende poder realizar todas operaciones posibles.


Por ejemplo, el siguiente mtodo que pertenece a la clase AnalizadorSemantico
verifica que la instruccin ingresada para crear una tabla est correctamente escrita
con respecto a la semntica:


private void semanticaCREAR() {
//"CREAR TABLA alumno ( nombre cadena, edad entero, nota real;
CLAVE (nombre))";
String nom_tabla = tokens.get(2).lexema();
Tabla t;

t = regTablas.recuperar(nom_tabla);

int index = 4;
-25-
String tipoDato;
String nombre;
String tipo = "";
int pos = 0;
int confirmado;

if (t == null) {
confirmado = JOptionPane.showConfirmDialog(frame, "La Tabla "
+ nom_tabla + " No existe.\n"
+ "Desea Crearlo?");

if (JOptionPane.OK_OPTION == confirmado) {

t = new Tabla(nom_tabla);

while (tokens.get(index).tipo().equals("identificador")) {
tipoDato = tokens.get(index + 1).lexema();
nombre = tokens.get(index).lexema();
if (tipoDato.equals("cadena")) {
tipo = "cad_car";
} else {
if (tipoDato.equals("entero")) {
tipo = "num_entero";
} else {
if (tipoDato.equals("real")) {
tipo = "num_real";
}
}
}
t.poner(new Atributo(tipoDato, tipo, nombre, pos));
pos++;
index = index + 3;
}

t.setIndice(tokens.get(tokens.size() - 3).lexema());

//tablas.add(t);
regTablas.add(t);

PrintWriter file;
try {
file = new PrintWriter(nom_tabla + ".txt");
file.close();
} catch (FileNotFoundException e) {
System.out.println("Excepcion 1");
}
}
} else {
JOptionPane.showMessageDialog(frame, "La Tabla " + nom_tabla
+ " ya existe!", "Error", JOptionPane.ERROR_MESSAGE);
}
}



-26-




8. Interfaz Grfica de la aplicacin:

Esta imagen nos muestra la ventana original de la aplicacin donde ha sido
introducida la instruccin:


SELECCIONAR (TODO) DE empleados DONDE (edad > 0)



























-27-
En esta otra imagen se comprueba como la instruccin introducida se ha realizadop
correctamente.





















-28-
9. RESULTADOS:


En primer lugar en la realizacin de este proyecto pudimos observar lo
que java nos puede ofrecer al momento de crear programas debido al
hecho de ser orientado a objetos.

Analizamos que para la realizacin de una Base de datos la creacin de
consultas de base de datos consta de archivos que permiten realizar
muchas tareas diferentes con los datos que se pueden ver. Tambin se
pueden utilizar para controlar los registros que visualiza Base de datos
la consulta no contiene informacin de base de datos, si no tan solo las
instrucciones necesarias para seleccionar los registros y campos
requeridos de una base de datos.

Una base de datos es una coleccin de datos o informacin usados
para dar servicios a muchas aplicaciones al mismo tiempo. El proceso
de crear una base de datos no es fcil, comprende desde el anlisis de
un problema, hasta la implementacin fsica. La administracin de datos
es una tarea de responsabilidad ya que los procesos administrativos,
contables o de cualquier ndole estn basados y funcionarn sobre las
bases de datos.


10. CONCLUSIONES:

La programacin orientada a objetos expresa un programa como un
conjunto de estos objetos, que colaboran entre ellos para realizar tareas.
Esta aplicacin nos ayudo a conocer el funcionamiento interno de un
Analizador Sintctico.
Comprender la generacin de componentes lxicos generados por la
gramtica del lenguaje fuente.
Entender el tratamiento de errores sintcticos a travs de esta
aplicacin.


11. REFERENCIAS:

[Java, 2011] Pgina oficial de java http://java.com/es/

Deitel, Paul J. y Harvey M. Deitel Como programar en Java, Sptima edicin

Jorge Sanchez Sistemas Gestores de Base de Datos