universidad autonoma metropolitana148.206.53.84/tesiuami/uam8543.pdf · antecedentes historicos....

UNIVERSIDAD AUTONOMA METROPOLITANA

/ LICENCIATURA EN COMPUTACION

PROYECTO DE INVESTIGACION I1

UNA HERRAMIENTA DE CUARTA GENERACION.

/ " ALUMNO: LUIS ALBE:RTO GONZALEZ ." TORRES .. - , ,

. I

MATRICULA: 86329108 /

ASESOR : ROBIERTO SOLIS OBA . F c3 c:kl '3 "

UNIVERSIDAD AUTONOMA METROPOLITANA

IZTAPtUAPA.

IMPLEMENTACION DE SQL EN EL LENGUAJE DE PROGRAMACION C :

UNA HERRAMIENTA DIE CUARTA GENERACION.

A mis padres, que siempre me apoyaron, pero principalmente a mi madre , quien un cija tuvo un sueiio y quiso compartirlo conmingo pera hacerlo realidad.

INDICE

1 ) OBJETIVOS ............................................................................................. 1

2) INTRODUCCION ....................................................................................... 1

3) ANTECEDENTES HlSTORlCOS .............................................................. 2

4) DESARROLLO .......................................................................................... 4

5) EXPANSION DEL CODIGO ...................................................................... 11

5) CONCLUSIONES .................................................................................... 13

6) APENDICES

A) LEX ........................................................................................................ 14

B) YACC ..................................................................................................... 18

C) BTRIVE .................................................................................................. 22

D) GRAMATICA .......................................................................................... 25

E) SINTAXIS ............................................................................................... 28

F) CODIGO ................................................................................................ 35

G) ACCIONES LEXICAS .......................................................................... 88

H) ACCIONES SEMANTICAS ................................................................... 93

7) REFERENCIAS ...................................................................................... 105

OBTlETlVOS

El presente proyecto tiene como objetivo implementar un manejador de base de datos , tal que pueda trabajar junto con el lenguaje C ,de esta manera se pretende obtener un lenguaje híbrido , que tenga todas las herramientas de C (por que en realidad es la plataforma a partir de la cual se desarrolla este proyecto) mas las facilidades que brinda un manejador de bases de datos. En este punto debe hacerse un comentario. El manejador de bases de datos (MBD de aquí en adelante) es tambien un hibrldo de otros dos . Por una parte se utilizó gran cantidad de instrucciones que se encuentran en DBASE Ill Plus , pero en cuanto al manejo mismo de las tablas de la base , se optó por las facilidades que brinda el SQL , el cual es un lenguaje de consulta completamente relaciona1 (a diferencia de DBASE Ill ,el cual solo lo simula) .

En los siguientes párrafos se explicará su funcionamiento general , iniciando desde un punto de vista operacional hasta los detalles técnicos mas importantes.

INTRODUCCION

Para cubrir los objetivos planteados :se propone seguir los siguientes pasos , que a grandes razgos conforman la totalidad del proyecto:

a) Plantear la gramática.

Por plantear la gramática se entiende implantar la gramática del MBD en la de C . AI hacer esto debe tenerse en cuenta que exiten algunas instrucciones que son comunes en ambos lenguajes , las cuales son obviamente eliminadas de la gramática.

b) lmplementarlo por medio de un generador de análisis sintáctico.

Una vez que se tiene la gramática debe implementarse. Para esto se utiliza YACC para generar el analizador sintáctico.El proceso de "depuración" de la gramática se complica debido a la aparición de conflictos de tipo shiftlreduce y de conflictos reduceheduce , los cuales se explicarán mas adelante.

c) Diseñar las librerias requeridas.

Deben diseñarse las librerias necesarias para el lenguaje que se pretende implementar.El proyecto debe tomar el lenguaje especificado , y hacer expansiones de tal manera que obtenga en la salida código en C con llamadas a las funciones definidas en la libreria , de manera que pueda ser compilado y ligado por un compilador de C . Las librerias deben ser diseñadas con la idea de que sea facil la migracion a un manejador de archivos cualquiera, como es Btrieve,xtrieve, o incluso en un ambiente UNIX.

UAM 1

d) Realizar la expansion de la gramática planteada.

La gramática propuesta debe ser expandida a código en lenguaje C de tal manera que un compilador produzca un programa en código objeto. Esto le da gran flexibilidad al proyecto , ya que C es facilmente transportable ,independientemente de la maquina que se trate , lo cual no siempre es posible con los manejadores de bases de datos.

ANTECEDENTES HISTORICOS.

Antes de comenzar con la parte técnica , se da a continuación una breve historia de los compiladores , tema del que trata en gran parte este proyecto , y que es importante tener en cuenta .

Parelelo al desarrollo de la ciencia de la computación y de las maquinas correspondientes,desde la época de Charles Babbage fue tomando auge la técnica relativa a los metodos de suministrar las instrucciones a las maquinas con vistas a realizar un determinado trabajo de cálculo.

Se reconoce generalmente como la primera gran pionera en este campo a Lady Ada Augusta Lovelace , única hija legitima del poeta ingles Lord Byron , nacida en 1815.

Los ultimos años de su corta existencia Lady Lovelace los dedicó a la interpretación de los trabajos de Babbage referentes a su Equipo Analítico.

Lady Lovelace planteó que en una larga serie de instrucciones debía haber necesariamente varias repeticiones de una misma secuencia. Y que consecuentemente debía ser posible establecer un solo grupo de tarjetas perforadas para este grupo de instrucciones recurrentes. Sobre este mismo principio trabajaron posteriormente los conocidos maternaticos ingleses Alan Turing y John Von Neumann.

Poco mas de un siglo despues de la lnuerte de Lady Lovelace,otra mujer estaba interesada en la programacion de la prilnera computadora digital , la Mark l.

Grace M. Hooper fue una de las pioneras en el campo de los idiomas de programación , especialmente de Cobol (Common Business Oriented Languaje) , un idioma especialmente concebido para su utilización con equipos de diferentes fabricantes y que expresa los problemas de manipulación y elaboración de datos en forma narrativa ordinaria en ingles.

En 1952 Grace Hooper publico su primer ensayo sobre autoprogramadores (compilers) , que le valio ser nombrada directora e ingeniero de sistemas de la Division Univac de la Sperry Rand Corp. Este documento de gran importancia tecnica seria el primero de muchos otros (mas de 50) publicados por ella relacionados con idiomas y otros elementos de programación.

UAM 2

Los trabajos de Grace Hooper en materia de programación llevaron al desarrollo de las subrutinas (subprogramas) y por extensión a la creación de las colecciones de las subrutinas,un procedimiento eficiente y económico de eliminar errores en la programación y de disminuir considerablemente el esfuerzo requerido para poder programar.

Las generaciones de lenguajes de programación pueden asociarse con las generaciones de computadoras en las que operan.

La primera genaración de lenguajes de programación se lleva a cabo de por medio de conectar tableros de cableado a la computadora.La arquitectura de las máquinas estaba basado en tubos de vacío.

La segunda generación utilizó tarjetas perforadas , mientras que el desarrollo de los transistores cambiaron radicamente su construcción y operación.

La tercera generación puede calificarse como descriptiva, ya que se le dice a la máquina como debe ejecutar cada proceso , paso por paso. Las instrucciones que se utilizan son de un nivel mas alto , ya que 'pueden ser entendidas a nivel humano.

La cuarta generación tiene la caracteristica de ser una programación imperativa , es decir, solo debe indicarse a la máquina que es lo que debe hacerse , no como hacerlo.

A manera de ejemplo , digamos que se necesita ordenar la información referente a los datos de empleados contenidos en un archivo. Para hacerlo con un lenguaje de tercera generación debe abrirse el archivo , leer los datos , programar un algoritmo de ordenamiento para crear las llaves necesarias o simplemente reescribir a disco. En un lenguaje de cuarta generación esto no es necesario, simplemente se indica que ordenamiento se quiere realizar sobre alguna llave en especial , y el resto se efectua de manera transparente para el usuario.

UAM 3

DESARROLLO

Primeramente debe comentarse que es lo que hace este proyecto.La entrada que recibe es un archivo con código sin expander , el cual puede contener unicamente código en C , en este caso el programa no hace nada (no tiene nada que expander) o puede darse el caso que tenga en su gran mayoría instrucciones del MBD , en cuyo caso expande todo el código y deja código fuente en C y llamadas a funciones de biblioteca definidas anteriormente.

El caso mas interesante ocurre cuanldo el código fuente a procesar se tiene tanto instrucciones en C (código de gran robustez) e instrucciones en el MBD (facilita el desarrolo de aplicaciones.) , dejando unicamente código en C.

Para lograr esto , primero se tuvo que definir la gramática a utilizar , la cual incluye al C standard definido por ANSI en 1989 , la parte de DBASE Ill PLUS (omitiendo el manejo de tablas) y el manejo mismo de la base de datos de SQL.

Para implementar la gramática se utilizó el generador de analizadores léxicos LEX y el generador de analizadores semánticos YACC.

El código que producen los generadores mencionados anteriormente fueron diseñados para usarse conjuntamente , a grandes razgos se menciona la forma en que se utilizan.

El uso de LEX y YACC puede comprenderse en dos etapas :

a) Generación del analizador. Para obtener el código en C que se encarga de realizar el análisis , se requiere definir las especificación, que es la entrada para LEX y YACC . En el caso de LEX se deben especificar las reglas léxicas que forman parte del lenguaje a desarrollarse.De esta manera , un identificador válido debe comenzar con un símbolo alfabético ([a..z,A.. Z]) y puede continuar con mas símbolos alfabéticos o números , pero no con símbolos distintos. El archivo que genera LEX se llama 1exyy.c , y la función que se debe llamar para obtener un nuevo token se llama YYW).

En el caso de YACC deben esplecificarse las acciones gramaticales y las acciones semánticas que se deben realizar en cada caso. De esta manera , una declaración de función debe comenzar con un identificador ,seguir con una lista de declaración de variables y terminar con el cuerpo de la función (esto a manera de ejemplo gramatical). Las acciones semánticas se realizan cada vez que sea necesario expandir una llamada .

b) Interacción de los analizadores. Para que el analizador gramatical pueda funcionar, requiere saber que token se encuentra en la entrada . Para lograrlo, utiliza la función yylex() definida en el archivo 1exyy.c . La función que declara YACC para realizar el análisis de código se llama yyparseo. El archivo que se quiere analizar debe abrirse con fopen y asignarse el apuntador a la estructura asociada al archivo a la variable global llamada yyin , definida en 1exyy.c .

UAM 4

http://desarrollarse.De

Para mas información sobre el uso de LEX y YACC , consultar los apendices correspondientes presentados mas adelante.

La gramática debe ser libre del contexto,que no tenga ambigüedades,que no tenga producciones inalcanzables y que no tenga conflictos.Esta es quiza la parte mas dificil al momento de depurar la gramática, debido a que son mas difíciles de detectar.Existen dos tipos de conflictos , el primero se presenta cuando la gramática puede continuar leyendo al rrlenos un token de la entrada o puede reducir una producción,este conflicto SE! conoce como shiftlreduce . El segundo tipo de error se presenta cuando la gramática puede reducir dos producciones distintas con un mismo token ; este tipo de error SE: conoce como reduceheduce.

Para implementar la gramática , se utilizó el programa llamado YACC , el cual convierte una gramática libre del contexto a un conjunto de tablas para construir un autómata el cual ejecuta un algoritmo de parsing. El archivo de salida , ytab.c , puede ser compilado por un compilador de C y obtener un programa , el que debe ser cargado con el programa de análisis léxico . Para obtener el analizador léxico se utilizó el programa generador de análisis léxicos LEX , cuya salida es un programa en código fuente en C que es directamente utilizable por YACC.

Conflictos shiftheduce.

A continuación se muestra una sección de la gramática con un conflicto shiftheduce y la forma de eliminarlo.

/*Section de la gramática con conflicto shiftheduce. */ Expresion-Unaria : Expresion-Posfija

I Cod-mas-mas Expresion-Unaria I Cod-menos-menos Expresion-Unaria I Operador-Unuario Expresion-Cast I Cod-ziseof Cod-paren-abre Nombre-De-Tipo

I Cod-ziseof Expresion-Unari,a Cod-paren-cierra

Operador-Unuario : Cod-ampersand I Cod-por I Cod-mas I Cod-menos 1 Cod-tilde 1 Cod-admira

Lista-Expr-Argum-O-Nada : Lista-Expresiones-Argumento I

UAM 5

Cuerpo-Expr-Posfija : Cod-corchete-abre Expresion Cod-corchete-cierra

Cod-paren-cierra: 1 Cod-paren-abre Lista-Expr-Argum-O-Nada

I Cod-punto ldentificador 1 Cod-flecha ldentificador 1 Cod-mas-mas U I Cod-menos-menos

Expresion-Posfija : Expresion-Primaria I Expresion-Posfija Cuerpo-Expr-Posfija

Expresion-Primaria : ldentificador I Constante I Cod-caracteres I Cod-paren-abre Expresion Cod-paren-cierra

/*Fin de sección de la gramática con conflicto.*/

A continuación se lista una sección del .archivo y0utput.c , en donde se muestran los conflictos encontrados.

11 1: shifvreduce conflict (shift 276 , red'n 230) on Cod-mas-mas

11 1: shiftheduce conflict (shift 277 , red'n 230) on Cod-menos-menos state 11 1

Expresion-Unaria : Expresion-Posfija- Expresion-Posfija : Expresion-Posfij'a-Cuerpo-Expr-Posfija

Cod-paren-abre shift 273 Cod-corchete-abre shift 272 Cod-punto shift 274 Cod-mas-mas shift 276 Cod-menos-menos shift 277 Cod-flecha shift 275 . reduce 230

Cuerpo-Expr-Posfija goto 271

state 276 Cuerpo-Expr-Posfija : Cod-mas-mas (246)

. reduce 248

UAM 6

state 277 Cuerpo-Expr-Posfija : Cod-menos-menos (249)

. reduce 249

El conflicto se debe en que al capturar el token ++ (Cod-mas-mas) o el token -- (Cod-menos-menos) la gramática puede continuar capturando tokens debido a la produccion Expresion-Unaria:

Expresion-Unaria : Expresion-Posfija 1 Cod-mas-mas Expresion-Unaria I Cod-menos-menos Expresion-Unaria I Operador-Unuario Expresion-Cast

I Cod-ziseof Cod-paren-abre Nombre-De-Tipo Cod-paren-cierra I Cod-ziseof Expresion-Unaria

Por otra parte,la siguiente producción se reduce al encontrar los mismos tokens:

Cuerpo-Expr-Posfija : Cod-corchete-abre Expresion Cod-corchete-cierra I Cod-paren-abre Lista-Expr-Argum-O-Nada Cod-paren-cierra I Cod-punto ldentificador 1 Cod-flecha ldentificador 1 Cod-mas-mas I Cod-menos-menos

La producción que une a las dos anteriores es la siguiente:

Expresion-Posfija : Expresion-Primaria 1 Expresion-Posfija Cuerpo-Expr-Posfija

Para eliminar el conflicto es necesaric) que el token que lo produce no permita hacer shift en una producción y reduce en otra.Esto se logra modificando la gramática.Notese que se podria modificar la producción anterior de la siguiente manera:

Expresion-Posfija : Expresion-Posfija Cuerpo-Expr-Posfija

Con lo cual no se permite que se acumulen expresiones primarias , de esta forma , no se permiten expresiones del siguiente tipo:

ldent ++ ++ ++

que no es muy frecuente , debido al que es mas claro implementarlo de la siguiente forma:

ldent += 3

Conflictos reduceheduce.

UAM 7

Ahora se vera la forma de eliminar un conflicto reduceheduce.

A Continuación se muestra una parte de la gramática en la cual aparece un conflicto de tipo reduceheduce :

Especificadores-De-Declaracion : Especificador-Categoria-Almacenamilento Especificadores-De-Declaracion I Especificador-DeJipo Especificadores-De-Declaracion 1 Calificador-De-Tipo Especificadores.-De-Declaracion

Especificador-De-Tipo : Cod-void I Cod-char I Cod-short I Cod-int I Cod-long I Cod-float I Cod-double 1 Cod-signed I Cod-unsigned I Especificador-Estructura-O-Union 1 Especificador-Enum I Nombre-Typedef I Cod-fecha I Cod-cadena I Cod-booleano I Cod-archivo

Nombre-Typedef : ldentificador

Lista-De-ldentificadores : ldentificador I Lista-De-ldentificadores Cod-coma ldentificador

A continuación se muestra una sección del archivo y0utput.c donde se muestra el conflicto:

99: reduceheduce conflict (red'ns 106 and 130 ) on Cod-coma 99: reduceheduce conflict (red'ns 106 and 1:30 ) on Cod-paren-cierra state 99 Lista-De-ldentificadores : Identificador-. (106) Nombre-Typedef : Identificador- (1 30)

Cod-coma reduce 106 Cod-paren-cierra reduce 106 . reduce 130

UAM 8

Se puede ver que el conflicto aparece debido a que puedereducirse con un mismo token (Identificador) dos producciones diferentes :


Lista-De-ldentificadores : ldentificador 1 Lista-De-ldentificadores Cod-coma ldentificador

Para corregir este conflicto , debe modificarse la gramática de manera que con un mismo token no se reduzcan dos producciones. Para lograr esto puede modificarse la gramática de la siguiente manera:

Especificadores-De-Declaracion: Especificador-Categoria-Almacenamiento Especificadores-De-Declaracion I Especificador-De-Tipo Especificadores-De-Declaracion I ldentificador Especificadores-De-Declaracion-O-Nada

Especificador-De-Tipo : Cod-void I Cod-char I Cod-short 1 Cod-int 1 Cod-long I Cod-float 1 Cod-double 1 Cod-signed I Cod-unsigned I Especificador-Estructura-O-Union 1 Especificadclr-Enum 1 Cod-fecha 1 Cod-cadena I Cod-booleano I Cod-archivo

Lista-De-ldentificadores : ldentificador I Lista-De-ldentificadores Cod-coma ldentificador

Notese que se elimino la producción


y se escribio directamente en Especificadores-De-Declaracion , de esta manera se elimina el conflicto reduceheduce.

UAM 9

Manejo de tablas.

Para realizar el manejo de tablas en este proyecto se utilizo el sistema manejador de registros Btrieve. Por medio de Btrieve es posible crear, abrir, consultar, insertar, eliminar, actualizar, cerrar y operar sobre varios registros en una tabla. Para una explicación mas detallada , consultar el apendice C .

UAM 10

EXPANSION DEL CODIGO.

Las salidas que deja el programa son dos archivos en código C, el primero es un archivo que contiene todas las funciones del MBD que se llamaron , pero de manera expandida ,el segundo archivo esta constituido por el código C original mas tres archivos de inclusión y las llamadas a las funciones expandidas.para aclarar esto , supongamos que se tiene un archivo en lenguaje sin expander y que se desea procesar :

/*ARCHIVO : CREAFECH.C */

DEFINE TABLE FECHA[l] = ~'Llave",lNTEGER,1,UNlQUE,NONULL.S), ("Fecha",CHAR,30,NO,NONULLS, C'hora",CHAR130,N0,NONULLS

1;

void main() CREATE FECHA;

AI procesar este archivo , se tiene como resultado a CREAFEC-.C y al archivo CREAFEC-.EXP :

CREAFEC-.C :

#include "turcbtrv.c" #include "bib1io.c" #include "creafec-.exp" void main() -CREATE-FECHA(); ;

CREAFEC-.EXP :

struct -FECHA int Llave; char Fecha[30]; char hora[30]; ;

void -CREATE-FECHA() struct Espec-Archivo RegArchivojnt TamPag,Longitud;

Longitud = sizeof(struct -FECHA); TamPag = CalculaTamPag(Longitud); Llena-Espec-Arch(&RegArchivo,Longitud,TamPag, 1,132,O); Llena-Espec-Llave(&RegArchivo. Llaves[O], 1,2,256,0); - STATUS = BTRV(CREATE,BLOQUEGLOB,&RegArchivo,64,"FECHA.dbe",-

1); if (-STATUS != O) ErrorBtrieveCSTATlJS);

UAM 11

El archivo "turcbtrv.c" es la interface entre el lenguaje C y BTRIEVE , que es el manejador de archivos usado.

El archivo "bib1io.c" contiene definiciones y mensajes de error necesarios al interactuar con BTRIEVE , su listado se encuentra en el apendice C.

En la declaracion de la tabla :

DEFINE TABLE FECHA[l] = f'Llave",lNTEGER,I,UNlQUE,NONULLS), f1Fecha",CHAR,30,N0,NONUL.LS, ("hora",CHAR,30,NO,NONULLS)

1;

se tienen 3 campos , a continuación se describe cada uno de los componentes de uno de los campos.En el caso del primero , se tiene que se llama Llave , es un entero , la longitud no se toma en cuenta (se sabe que tiene 2 bytes) es una llave que no acepta duplicados,y no pueden guardarse valores nulos.

Si se declara mas de una llave ( para fines estrictamente tecnicos , pueden declararse datos y llaves en el orden que se quiera , aunque desde un punto de vista operaciona1,es importante el orden en que se declaran las llaves) , la salida seria una estructura con los mismos campos , pero primero con las llaves y despues con los datos.

Obviamente el manejo de archivos es totalmente transparente al usuario , as¡ como los campos que la componen , por lo que el lenguaje propuesto es una alternativa sumamente competitiva.

UAM 12

CONCLIJSIONES.

En la primera fase del proyecto, que es planteamiento e implementación de la gramática , La gramática propuesta tiene una ventaja para las personas que conocen C y Dbase : no tienen que aprender un nuevo lenguaje para obtener las ventajas del propuesto , debido a que ya lo conocen. Efectivamente,la gramática propuesta tiene por objetivo unir lo mejor de los dos lenguajes , que en C es el 100% , mientras que Dbase se ve enriquecido por comandos de SQL.

UAM 13

APENDICE A LEX.

LEX es un generador de analizadores léxicos , el cual fue empleado en el presente proyecto para ser usado en comt>inación con YACC.

A continuación se describe la forma en clue se usa LEX.

LEX recibe como entrana un archivo fuente que debe tener la siguiente estructura:

Definiciones YO % Acciones Iéxicas Yo Yo funciones de usuario

Definiciones.

La sección de Definiciones debe tener una lista de definiciones ,en la cual se escribe por cada definición un ldentificador y la expresion regular que la define o el rango de caracteres que la componen.

De esta manera , para indicar que se espera una letra , se puede definir como :

Letra [a-A-Z]

Con esto se especifica que cualquier letra ya sea minuscula o mayuscula entre la a hasta la z pertenece al conjunto "Letra".

LEX tiene caracteres de control especiales , por ejemplo al principio de un conjunto encerrado entre corchetes cuadrados significa el complemento de ese conjunto.Asi para señalar todos los caracteres excepto el salto de linea , podria ser de la siguiente forma:

define ["O

Si se quisiera especificar un numero decimal , primero se define un Numero y despues se especifica la expresion regular.

D ~ 9 1 NUMERO DD)* DECIMAL Numero[.]r\Jumero

De esta forma D representa un digito cualquiera , NUMERO es un entero y DECIMAL representa a un numero con punto flotante.Notese el asterisco en la parte final de NUMERO ; El primer D significa que debe comenzar con un numero , el segundo D)* significa que debe continuar con cero o mas digitos.

UAM 14

Para terminar esta primera sección de LEX se dara un ultimo ejemplo, en este caso , la forma de escribir un Identificador , (que puede servir para un identificador de variable o de función):

Token Letra(LetralD)*

El ejemplo anterior indica que un Token debe comenzar con una Letra y puede continuar con las letras y numeros que se quiera.

Acciones Iéxicas.

En la sección de acciones léxicas , se (definen los tokens que se permiten dentro del lenguaje.Por ejemplo , si se quiere especificar el token que describe un numero decimal , puede hacerse de la siguiente forma :

Ya Ya

D [o-91 NUMERO DD)* DECIMAL Numero[.]Numero

Ya Yo

DECIMAL return(Cod-constante-flotante);

Un lenguaje requiere de símbolos para especificar operaciones , si estos símbolos pueden reflejar una idea natural de lo que se esta haciendo, y son pequeños , el lenguaje sera mas facil de usarse.

Por ejemplo , algunos operadores de C pueden definirse de la siguiente manera :

Y" return(Cod-paren-abre); 11)1' return(Cod-paren-cierra);

I ' & 8 l V 1 return(Cod-doble-ampersand); 11+=11 return(Cod-mas-igual); " return(Cod-igual-igual);

"++" return(Cod-mas-mas); ll"11

Finalmente las funciones del usuario son declaraciones de variables y funciones normales en código C , pero que se escriben directamente en el archivo 1exyy.c para ser llamados dentro de la sección de acciones Iéxicas.

Por ejemplo , una vez que se ha id'entificado un token como una secuencia de caracteres , puede tratarse de una palabra reservada o un identificador. Para saber de

UAM 15

que se trata y regresar el valor correcto , puede implementarse una función que realice la busqueda del token en una tab1.a de cadenas , y regresar el valor correcto. Por ejemplo :

Letra [a-A-Z] Token Letra(LetralD)*

YO %

noken return(RegresaToken(yytext));

Yo Yo

int Regresa-Token(char *Token) int Inic;io,Final,Mitad,Result; static char *PalabraReservada[] = "ALL", "ATTRIBUTE", "BOF", "BOOLEAN", "BOTTOM", "BOX', "BY", "CDELETE", "CHAR", "CINSERT", "CLOSE", "COL", 'CONTINUE", "CREATE", "CURSOR", "DATE", "DATEADDNUM", "DATECMP", "DAY", "DECLARE", "DEFINE", "DELETE", "DELETED", "DEVICE", "DOUBLE", "DUPS", "END", "EXFILE', "FILE", "FLOAT", "FOlR", "FOREACH", "FOUND", "FROM", "GET", "GETS", "GO", "IN", "INDEX', "INPUT", "INSERT", "INTEGER", "INTO", "LOCATE", "LOWER", "LUPDATE", "MONTH", "NEXT", "NO", "NONULLS", "NULLS", "NUMERO", "ON", "OPEN", "ORDER", "PICTURE", "PRINT", "REINDEX', "REPLACE", "REPLICATE", "RIGHT", "ROUND", "ROWI", "RTRIM", "SAY", "SCREEN", 'SEEK', "SELECT", "SET", "SORT", "STUFF", "SUM", "TABLE", "TEMP", "TO", "TOP", "TRIM", "UNIQUE", "UPDATE", "UPPER", "VALUES", "WHERE", "WHILE", "WITH", "YEAR", "arroba", "auto", "break", "case", "char", "close", "const", "continue", "default", "define", "do", "double", "elif", "else", "endif", "enum", "error", "extern", "float", "for", "goto", V", "include", "int", "line", "long", "pragma", "register", "return", "short", "signed", "sizeof", "static", "struct", "switch", "typedef", "undef", "union", "unsigned", "void", "volatile", "while" ;

Inicio = O; Final = 126; Mitad = (Inicio + Final) YO 2; if (strcmp(PalabraReserada[lnicio],Token) != O)

while ( Inicio < Final)

Mitad = (Inicio + Final) / 2; if (strcmp(Token,PalabraReservada[Mitad]) e= O)

else Final = Mitad;

Inicio = Mitad + 1; 1 if (strcmp(Token,PalabraReservada[Mitad]) <= O)

UAM 16

Result = Mitad;

Result = Mitad + 1;

return(Resu1t);

return(1dentificador);

else

if (strcmp(Token,PalabraReservada[ResuIt]) == O)

else

1

return(1nicio); else

La función yylex() se encarga de regresar un nuevo token de la entrada . El archivo que se desea analizar deber abrirse antes de llamar a yylex , y el descriptor de archivo se debe asignar a la variable global yyin , por medio de fopen.

UAM 17

YACC.

YACC es un generador de analizadores sintácticos (yet another compiler- compiler).Convierte una gramática libre del contexto a un conjunto de tablas para un autómata simple , el cual ejecuta un algoritmo de parsing tal como se describe en la literatura de construcción de compiladores.

El archivo de salida es ytab.c , y debe ser compilado por un compilador de C para producir un programa analizador.La funci6n que se debe llamar una vez que el código ha sido generado es yyparseo.

El archivo de definiciones gramaticas y acciones semánticas tiene la siguiente estructura :

Definiciones Yo Yo Acciones gramaticales YO % Funciones del usuario.

Para definir los símbolos terminales y el tipo que tiene una producción se utiliza la sección de Definiciones.

Para definir los símbolos terminales , se realiza de la siguiente forma:

%token Cod-mas,Cod-menos,Cod-igual , ... Yo O!O

Yo Yo

Para definir que una producción tiene un tipo determinado , por ejemplo , que es un apuntador a caracter , se puede realizar de la siguiente forma:

%union

char *Cadena;

%token Cod-mas,Cod-menos,Cod-igual , ...

%type <Cadena> Unidad_De-Traduccion,Declaracion_Externa,Definicion_De-Funcion, Declaracion,Especificadores_De-Declaracion,Declarador, Proposicion-Compuesta , Lista_De-Declaraciones_O_Nada

%% Yo Yo

UAM 18

En el código anterior se tiene una lkta de producciones con el tipo de dato apuntador a caracter , de ahora en adelante , se puede hacer referencia a estas producciones en la seción de acciónes gramaticales.

En la sección de acciones gramaticales se especifica la gramática que se quiere analizar, por ejemplo :

%union char *Cadena;


%type <Cadena> Unidad-De-Traduccion,Declaracion-Externa,Definicion-De_Funcion, Declaracion,Especificadores-De_Declarac,ion,Declarador, Proposicion-Compuesta , Lista-De-Declaraciones-O-Nada

%%

Unidad-De-Traduccion : Declaracion-Ex.terna I Unidad-De-Traduccion Declaracion-Externa

Declaracion-Externa : Definicion-De-Funcion I Declaracion

Definicion-De-Funcion : Especificadores8-De-Declaracion Declarador Lista-De-Declaraciones-O-Nada Proposicion--Compuesta

Proposicion-Compuesta I Declarador Lista-De-Declaraciones-O-Nada

%Yo

Las acciones gramaticales as¡ descritas determinan la forma en que se realiza una producción.De esta manera , una Definición-De-Funcion puede formarse de dos maneras distintas , la primera indica que una función puede comenzar con la especificación de tipo de dato que regresa la función (Especificadores-De-Declaración), Continuar con un identificador y la lista de parametros (Declarador) , continuar con la lista de tipos de datos de los parametros (Lista-De-Declaraciones-O-Nada) y finalmente , el cuerpo de la función (Propocición compuesta). Una manera alternativa de realizar la definición de una función es similar a la anterior, pero omitiendo la especificación de tipo que regresa la función.

Para implementar las acciones semánticas , esta se escriben como instrucciones de C entre llaves ; en el código anterior se puede implementar de la siguiente manera

UAM 19

http://produccin.De

%union

char *Cadena;


%type <Cadena> Unidad_De_Traduccion,Declaracion_Extema,Definicion_De_Funcion, Declaracion,Especificadores-De_Declaracion,Declarador, Proposicion_Compuesta,Lista_De-Declar;3ciones-O-Nada,

Unidad-De-Traduccion : Declaracion-Externa I Unidad-De-T'raduccion Declaracion-Externa

Declaracion - Externa : Definicion-De-Funcion $$=$1 ; printsm(&Codigo,$$,O) ;

I Declaracion $$=$1 ;IDrintsm(&Codigo,$$,O);LiberaCad($$); I Declaracion-Tabla $$=NULL;

Liberacad($$);

Definicion-De-Funcion : Especificadores-De-Declaracion Declarador CadAux $3=UneCads($l,$2,3); Lista-De-Declaraciones-O-Nada $3=UneCads($3,$5,3); Proposicion-Compuesta $$=UneCads($3,$7,3);

I Declarador Lista-De-Dec:laraciones-O-Nada CadAux $3=UneCads($l,$2,3); F'roposicion-Compuesta $$=UneCads($3,$5,3);

YO Yo

De la tercera producción (Definicion-De-Funcion) se puede ver la acción semántica $3=UneCads($l,$2,$3); . Esto quiere decir que se asigne el resultado de la función UneCads al valor del símbolo no terminal CadAux. Notese que $1 hace referencia al primer símbolo no terminal que en este ejemplo es Especificadores-De-Declaracion , $2 a Declarador , etc. A UneCads se le mandan como parametros los apuntadores a caracter del primer y segundo símbolos no terminales.

Nótese que se utiliza la producción CadAux como un "almacen" temporal que contiene un resultado intermedio mientras se arma la definición de la función. ¿Por que no se utiliza un apuntador a caracter para guardarlo.? Esto obedece a que se debe tener la seguridad de que no se va a cambiar el valor de dicha variable hasta regresar a la siguiente acción semántica de la misma producción para continuar con su procesamiento , pero esto no s'iempre es posible , ya que las producciones son recursivas , y una misma variable no puede servir para este fin , pero utilizar una

UAM 20

producción de esta manera si sirve , ya que el arbol de parse se va guardando en una pila , garantizando que se tiene el valor correcto de la cadena al momento de continuar el análisis.

UAM 21

APENDICE C BTRIEVE.

Btrieve es un sistema manejador de registros que provee las funciones necesarias para guardar , recuperar , y actualizar lo:; datos de las tablas en disco. Debido a las tecnicas y estructuras que utiliza , se pueden ignorar las estructuras fisicas de los archivos , mantenimiento de indices y problemas de concurrencia , concentrandose en los aspectos logicos y fisicos de las tablas y archivos que constituyen la base de datos.

Mantenimiento de indices.

Btrieve crea y mantiene automaticamente los indices en las tablas al momento de insertar , actualizar y borrar registros.Ademas , btrieve tiene las siguientes caracteristicas :

a) Soporta hasta 24 indices por archivo. b) Soporta creación y borrado de indices suplementarios despues de que el

c) Soporta 14 distintos tipos de datos. d) Soporta llaves duplicadas , modificables , segmentadas , nulas , manuales , y

archivo ha sido creado.

descendientes.

Especificaciones de archivos.

Los archivos creados por btrieve tienen las siguientes caracteristicas :

a) Archivos con tamaño de 4 billones de caracteres. b) lrrestricto numero de registros.

c) Habilidad para extender un archivo atraves de dos dispositivos de almacenamiento.

d) Definición de archivos consistente y rutinas de manejo. e) Estructuras de archivo consistentes.

Integridad de datos.

Btrieve usa varias tecnicas para asegurar la integridad de los archivos. Estas tecnicas incluyen :

a) Usando archivos pre-imagen para guardar imagenes de paginas de archivo antes de que los registros sean insertados , actualizados o borrados.

b) Usando procesamineto de transacción para mantener la consistencia entre los archivos durante multiples actualizaciones de archivos.

UAM 22

Descripción del uso de Btrieve.

Btrieve requiere de una interface con el lenguaje que se esta utilizando para el paso de parametros con el sistema manejador de registros . Para realizar esto en C se utiliza el header apropiado , especificamente , el archivo turcbtrv.c . El sistema manejador de registros (SMR de aqui en adelante) , es un programa que al correr queda residente en memoria . Para hacer uso de una función de Btrieve , se utiliza la función BTRV con los siguientes parametros :

BTRV(Operacion,Bloque_Posicion,Buffer_-Datos,Longitud_Buffer_Datos, Buffer-Llave, Numero-Llave)

BTRV siempre regresa un valor , si es O significa que la Operación se llevo a cabo exitosamente , y en caso de error regresa el numero correspondiente al tipo de error que ocurrio.

A continuación se especifica cada uno dle los paremetros de la función BTRV :

1. Operación : Indica la operación que se quiere realizar . Btrieve puede soportar hasta 36 operaciones distintas , las cuales incluyen abrir , cerrar o crear una tabla , insertar , actualizar, eliminar , buscar un registro , etc.

La operación debe ser un entero de 2 bytes que represente una operación valida.Btrieve no cambia nunca el valor de la operación.

2. Bloque-Posicion .Btrieve usa el bloque de posición para contener la posición del apuntador e información adicional para el acceso a un archivo en particular. Btrieve espera que el tamaño del bloque sea de 128 bytes de memoria.La aplicación debe asignar un unico bloque a cada archivo . Debe tenerse cuidado de que no se cambie la información que contiene una vez que Btrieve lo ha inicializado para trabajar con un archivo , de lo contrario podrian perderse datos o dañarse el archivo.

3. Buffer-Datos . El buffer de datos es un bloque de memoria que guarda información específica que se requiere para realizar una operación de Btrieve.

Por ejemplo , en una operación de inserción la información que se va a guardar se localiza en este buffer.

Btrieve no distinge la estructura de la información almacenada en el buffer de datos , sino que lo ve como un arreglo de bytes, por lo que se debe especificar la longitud del registro en el cuarto parametro , que se describe a continuación.

4. Longitud-Buffer-Datos. Como btrieve permite que se guarde en una tabla cualquier tipo de dato que el lenguaje anfitrion permita , se pueden almacenar arreglos , registros , estructuras , etc. pero se debe espocificar el tamaño que ocupa en memoria , debido a que Btrieve los ve como si fueran arreglos de bytes. Este parametro debe ser un entero de 2 bytes.

23

5. Buffer-Llave. Al realizarse una operación , debe mandarse como parametro el valor de la llave sobre la cual se realizara dicha operación.

6. Numero-Llave. Este parametro le dicte a Btrieve que ruta de acceso debe utilizar para una operación en particular.Para otrals operaciones , el numero de llave especifica la forma de abrir un archivo , drive logic0 , u otra informaci6n.Btrieve nunca cambia su valor.

UAM 24

APEhlDlCE D GRAMATICA.

A continuación se muestra la gramática Idel MBD que se pretende implantar en C:

Proposicion-Dbase : Visualizacion-De-Datos I Funciones-Dbase I Lenguaje-SQL

Funciones-Dbase : FuncionFecha I FuncionCaracteres I FuncionLogicos I FuncionNumerica

FuncionNumerica : Cod-COL Cod-paren,-abre Cod-paren-cierra I Cod-ROW Cod-paren-abre Cod-paren-cierra I Cod-DAY Cod-paren-abre Expresion-Cast

I Cod-YEAR Cod-paren-abre Expresion-Cast

I Cod-MONTH Cod-paren-abre Expresion-Cast

Cod-paren-cierra

Cod-paren-cierra

Cod-paren-cierra

FuncionFecha : Cod-DATECMP Cod"paren-abre Expresion-Cast Cod-coma Expresion-Cast Cod-paren-cierra

Cod-coma Expresion.-Cast Cod-paren-cierra 1 Cod-DATEADDNUM Cod-paren-abre Expresion-Cast

FuncionLogicos : Cod-EXFILE Cod-paren-abre Expresion-Cast

I Cod-FOUND Cod-paren-abre Cod-paren-cierra Cod-paren-cierra

FuncionCaracteres : Cod-REPLICATE Cod-paren-abre Expresion-Cast Cod-coma Expresion-Cast Cod-coma Expresion-Cast Cod-paren-cierra

I Cod-RIGHT Cod-paren-abre Expresion-Cast Cod-coma Expresion-Cast Cod-paren-cierra

I Cod-STUFF Cod-paren-abre Expresion-Cast Cod-coma Expresion-Cast Cod-coma Expresion-Cast Cod-coma Expresion-Cast Cod-coma Expresion-Cast Cod-paren-cierra

Cod-paren-cierra I Cod-TRIM Cod--paren-abre Expresion-Cast

I Cod-RTRIM Cocl-paren-abre Expresion-Cast

UAM 25

Cod-coma Expresion-Cast Cod-paren-cierra I Cod-CINSERT Clod-paren-abre Expresion-Cast

Cod-coma Expresion-Cast Cod-coma Expresion-Cast Cod-paren-cierra

Cod-coma Expresion-Cast Cod-coma Expresion-Cast Cod-paren-cierra

Cod-paren-cierra

Cod-paren-cierra

I Cod-CDELETE Cod-paren-abre Expresion-Cast

I Cod-UPPER Cod-paren-abre Expresion-Cast

I Cod-LOWER Ccld-paren-abre Expresion-Cast

Visualizacion-De-Datos : Marcos I Captura

Captura : Cod-INPUT ldentificador Cod-FROM ldentificador Lista-Lineas-Captura Cod-END Cod-INPUT

Lista-Lineas-Captura : Linea-Captura I Lista-Lineas-Captura Linea-Captura

Lista-Attrib : Cod-ATTRIBUTE Cod-paren-abre Lista-De-ldentificadores Cod-paren-cierra

Linea-Captura : Posicion-Cursor Cod-SAY Expresion-Primaria Cod-GET ldentificador Lista-Attrib

Posicion-Cursor : Cod-IN Expresion-Cast Cod-coma Expresion-Cast

Marcos : Cod-BOX Expresion-Primaria Coma-Numero Coma-Numero Coma-Numero Tipo-Marco-O-Nada

Coma-Numero : Cod-coma Expresion-Primaria

Tipo-Marco-O-Nada : Cod-DOUBLE I

Lenguaje-SQL : SELECT-SQL I DECLARE-SQL I DELETE-SQL I UPDATE-SQL I INSERT-SQL I Crear-Tabla I Abrir-Tabla I Cerrar-Tabla

UAM 26

SELECT-SQL : Cod-SELECT Lista--De-ldentificadores-O-Todos INTO-O-Nada Cod"FR0M ldentificador ORDER-O-Nada WHERE-O-Nada TEMP-O-Nada

Lista-De-Identificadores-O-Todos : Lista,-De-ldentificadores I Cod.-por

DECLARE-SQL : Cod-DECLARE ldentificador Cod-CURSOR Cod-FOR SELECT-SQL

DELETE-SQL : Cod-DELETE Cod-FROM ldentificador WHERE-O-Nada

INSERT-SQL : Cod-INSERT Cod-INTO ldentificador Cod-VALUES Cod-paren-abre Identifilcador Cod-punto Cod-por Cod-paren-cierra

UPDATE-SQL : Cod-UPDATE Identificador Cod-SET Cod-paren-abre Lista-Expresion-De-Asignacion Cod-paren-cierra WHERE-O-Nada

Lista-Expresion-De-Asignacion : Expresion-De-Asignacion I Lista-Efxpresion-De-Asignacion

Cod-coma Expresion-De-Asignacion

INTO-O-Nada : Cod-INTO ldentificador I

WHERE-O-Nada : Cod-WHERE Cod"paren-abre Expresion Cod-paren-cierra

I

ORDER-O-Nada : Cod-ORDER Cod-BY ldentificador I

TEMP-O-Nada : Cod-INTO Cod-TEMF' ldentificador I

UAM 27

APENDICE E SINTAXIS.

En este apendice se mostrara la sintaxis de las instrucciones que se incluyen en el presente proyecto.

ABREVIACIONES:

IdTabla : Es un identificador de la tabla con la que se va a trabajar. Debe tener a lo mas 8 caracteres , comenzando por un caracter alfabético.

ldentificador : Es un identificador clue tiene las mismas propiedades que un identificador en C. ???

ConstNumerica : Es una constante numerica valida en C. Expr-Cast : Es una expresion

RegTabla : Es una variable de tipo struct que tiene la misma estructura que una tabla . Leer TABLE .

CondicionC : Es una condición valida en C. AI momento de utilizarse en alguna de las instrucciones de SQL , los campos de alguna de las tablas se debe utilizar directamente sin agregarle la tabla , y las comparaciones entre cadenas debe efectuarse mediante las instrucciones de 12 (strcmp,strncmp,etc.)

Ejemplo :

SELECT FROM Agente WHERE ((CveAgente > 3001) &&

(strstr(Nombre,"RODRlGUEZ') != NULL));

En este ejemplo CveAgente y Nombre son dos campos de la tabla Agente.

ExprFecha : Es un campo de tipo DATE de una tabla definida con TABLE segun se explica mas adelante en DEFINE TABLE o puede ser una cadena de al menos 12 caracteres de largo.

Numero : Es un integer en C.

DEFINE TABLE

SINTAXIS : DEFINE TABLA <IdTabla~[-:ConstNumerica~] ListaCampos ;

UAM 28

Listacampos -> Campo I Listacampos , Campo

Campo -> <ldCampo>,<TipoDato>,<Longitud>, <TipoLlave>,<TipoValor>

TipoDato -> CHAR I INTEGER I CHAR I DATE I BOOLEAN I FLOAT

Longitud -> ConstNumerica

TipoLlave -> UNIQUE I DUPS I NO

Tipovalor -> NULLS I NONULLS

DESCRIPICION: Define la estructura de una tabla .Antes de comenzar a operar de cualquier forma con una tabla debe definirse apropiadamente.

El identificador de campo es cualquier identificador valido en C ,

Los tipos de datos estanespecificados claramente en la sintaxis,la longitud unicamente es tomadaen cuenta cuando el tipo de dato es un CHAR , pero se incluye para darle uniformidad a la sintaxis.

El TipoLlave indica si la llave es unica , permite duplicados o si no es llave.

El Tipovalor indica si se permiten valores nulos en la tabla o no.

TABLE

SINTAXIS : TABLE <ListaVars>

Para definir una variable de tipo struct con los mismos campos que una tabla determinada , se usa TABLE como si fuera un tipo de dato. Este unicamente es valido al usarse unicamente para definir variables , no como definición de funciones.

UAM 29

CREATE

SINTAXIS : CREATE <IdTabla>

DESCRlPlClON : Crea una tabla en el 'directorio actual segun las especificaciones dadas (leer DEFINE TABLE) en la definición de la tabla.No puede crearse una tabla que ya existe en el directorio actual.

OPEN

SINTAXIS : OPEN <IdTabla>

DESCRIPCION : Abre una tabla para modificarla. Una tabla que no ha sido abierta no puede ser modificada.Para poder abrir una tabla esta debio haber sido creada anteriormente y debe existir en el directorio actual.

INSERT

SINTAXIS : INSERT INTO <IdTabla> VALUES (<RegTabla.*>)

DESCRIPCION : Inserta el registro RegTabla en la tabla indicada por IdTabla. El registro a insertarse y la tabla destino deben ser definidas identicamente.

SELECT

SINTAXIS : SELECT * [INTO <RegTabla>] FROM <IdTabla> [WHERE (CondicionC)]

DESCRIPCION : Regresa todos los registros que se encuentren en la Tabla indicada por IdTabla (en caso de no irldicarse los registros que cumplan con una condición dada por medio de WHERE) o unicamente los especificados.SELECT debe usarse en combinación con la instrucción DECLARE,en caso de que se nececite consultar mas de un registro , de otra forma , SELECT regresara un mensaje de error si regresa mas de un registro.

Los campos que se incluyen en la condición WHERE no deben incluir al nombrede la tabla y la sintaxis de la misma es igual que en C.

DECLARE

SINTAXIS : DECLARE <Identificador> CURSOR FOR <SELECT>

UAM 30

DESCRIPCION : Esta instrucción permite realizar consultas sobre varios registros de una tabla (se debe recordar que la instrucxión SELECT solo permite realizar consultas sobre un registro especifico). DECLARE solo obtiene los registros que cumplan con la condición de SELECT , pero no permite manipularlos directamente , para hacerlo debe usarse la instrucción FOREACH , con l a cual puedene accesarse cada uno de los registros.

FOREACH

SINTAXIS : FOREACH <Identificador> [IIVTO <Variable>] ProposicionC

END FOREACH

DESCRIPCION : La instrucción FOREACH es en realidad una estructura de control (puede verse como un while en el que se cicla mientras existan registros).Esta permite procesar cada uno de los registros que se obtuvieron mediante la consulta de SELECT.El ldentificador debe ser el misrrlo que se uso anteriormente en la instrucción DECLARE, la Variable debe ser del mismo tipo TABLE del cual se realizo la consulta SELECT dentro de DECLARE.

UPDATE

SINTAXIS : UPDATE <IdTabla> SET (<ldTabla = RegTabla>) [WHERE (CondicionC)]

DESCRIPCION : Actualiza algunos o todos los registros de una tabla , dependiendo si se especifica WHERE o no.

DELETE

SINTAXIS : DELETE FROM <IdTabla> [WHERE <CondicionC>]

DESCRIPCION : Borra todos los registros de la tabla indicada por IdTabla solamente aquellos registros que cumplan con la condición en C indicada en la clausula WHERE.

CLOSE

SINTAXIS : CLOSE <IdTabla> I CLOSE ALL

DESCRIPCION : Cierra una o todas las tablas que en ese momento se encuentren abiertas.No pude cerrarse una tabla que no haya sido abierta anteriormente.

UAM 31

INPUT

SINTAXIS : INPUT <RegTabla> FROM <IdTabla> IN <Expr-Cast>,<Expr-C:ast> SAY <> GET <> ATTRIBUTE (")

END INPUT

FUNCIONES DE BIBLIOTECA.

COL

SINTAXIS : COL()

DESCRIPCION : Función que regresa el numero de la columna en la que se encuentra el cursor.

ROW

SINTAXIS : ROW()

DESCRIPCION : Función que regresa e l numero del registro en el que se encuentra el cursor.

DAY SINTAXIS : DAY(ExprFecha)

DESCRIPCION : Función que regresa el numero del dia del mes de la ExprFecha.

YEAR

SINTAXIS : YEAR(ExprFecha)

DESCRIPCION : Función que regresa el numero correspondiente al año de la ExprFecha.

DATECMP

SINTAXIS : DATECMP(ExprFecha,ExprFecha)

DESCRIPCION : Compara dos fechas , regresando O si son iguales , -1 si la primera fecha es menor que la segunda y 1 si la primer fecha es mayor que la segunda.

UAM 32

DATEADDNUM

SINTAXIS : DATEADDNUM(ExprFecha,Numero)

DESCRIPCION : Procedimiento que regresa el valor de ExprFecha mas los dias indicados en Numero (Numero puede ser positivo o negativo) en la misma variable de tipo DATE ExprFecha.

EXFILE

SINTAXIS : EXFlLE(NombreArchivo)

DESCRIPCION : Función que regresa 1 si encuentra el archivo especificado en NombreArchivo (NombreArchivo es una cadena que contiene un nombre y path de un archivo valido para DOS) en caso de no encontrarlo regresa O.

FOUND

SINTAXIS : FOUND()

DESCRIPCION : Función que regresa 1 si despues de realizar una operación de SQL se encontro el registro especificado y O en caso contrario.

REPLICATE

SINTAXIS : REPLICATE(CadDestino,CadFuente,Numero)

DESCRIPCION : Este procedimiento devuelve en CadDestino la CadFuente repetida Numero de veces.

RIGHT

SINTAXIS : RIGHT(CadDestino,Numero)

DESCRIPCION : Devuelve el Numero de caracteres especificados de la parte derecha de CadDestino.Si Numero es O se devuelve una cadena nula.

STUFF

SINTAXIS : STUFF(CadDestino,Numero,Numero,CadFuente)

DESCRIPCION : Sustituye CadFuente dentro de CadDestino , comenzando en el primer numero indicado hasta la longitud dada por el segundo numero.

UAM 33

TRIM

SINTAXIS : TRIM(CadDestino)

DESCRIPCION : Quita los espacios en blanco a la derecha y a la izquierda de la CadDestino.

RTRIM

SINTAXIS : RTRIM(CadDestin0)

DESCRIPCION : Quita los espacio's en blanco a la derecha de la cadena CadDestino.

CINSERT

SINTAXIS : CINSERT(CadDestino,Pos,CadFuente)

DESCRIPCION : Inserta la cadena CadFuente a partir de Pos en la CadDestino .

CDELETE

SINTAXIS : CDELETE(CadDestino,Nurnero,Numero)

DESCRIPCION : Elimina de la CadDestino la cantidad de caracteres que indica el segundo Numero , iniciando en la posición indicada por el primer Numero.

BOX

SINTAXIS : BOX(X1 ,Y1 ,X2,Y2,TipoMarc:o,Color)

DESCRIPCION : Pinta un marco en la pantalla , los valores X1,Yl indican la parte superior izquierda y =,Y2 indican la parbe inferior derecha. El tipo de marco puede ser O que es marco sencillo y 1 que es marco doble.

UAM 34

APENDICE E CODIGO.

A continuación se muestra el código desarrollado en el presente proyecto. En la siguiente figura se muestra la forma en que estan relacionados los archivos que lo componen.

Figura 1. Inclusion de archivos del proyecto

(”) (leuyy.c)

UAM 35

I*

Archivo : main.c

*I

.......................................................................................................................................... ..........................................................................................................................................

............................................................................................................................................ ............................................................................................................................................

#define Maximo 80

#include "std1ib.h" #include <string.h> #include <ctype.h> #include <stdio.h> #include <stdarg.h>

#ifdef UNlX #include "unix.c" #endif I* #define WDEBUG 1 O #define LEXDEBUG 10 *I extern unsigned char yytext[]; int extern yylineno; FILE *Expansion,*Codigo; char CODIGO[Maximo];

void allprint(Carac) char Carac;

1 printf("%c",Carac);

void sprint(Cadena) char *Cadena;

1 printf("%s (L %d)",Cadena,yylineno);

int debugger = 1 O; #include "ytabl .c" #include "ytab2.c" #include "1exyy.c"

void NomArchS(char *NomArch,char *Expansion,char *Llamadas) int Lugar;

if ( (Lugar = POS('.',NomArch)) > O) NornArch[Lugar] = 7x0';

if (strlen(NomArch) < 8) strcat(NomArch,"-'I);

else

NomArch[7] = I-';

UAM 36

NomArch[8] = 'k0'; 1

strcpy(Expansion,NomArch); strcpy(Llamadas,NomArch); strcat(Expansion,".exp"); strcat(Llamadas,".c");

1

void CapturaNombreArch(char *NombreArch,char *Llamadas,char *NomEsc) (char Opcion = 'R';

do

printf("\n%s","NOMBRE DEL ARCHIVO: "); gets(NombreArch); yyin = fopen(NombreArch,"r");

if (yyin == NULL)

printf("ERR0R EN LECTURA. %S NO ENCONTRADO.",NombreArch); exit(0);

1 while ( (yyin == NULL) && (Opcion != 'S') ); NomArchS(NombreArch,NomEsc,Llamadas); Expansion = fopen(NornEsc,"w"); Codigo = fopen(Llamadas,"w"); strcpy(CODIG0,NomEsc);

void ObtenExpresion(char *CadExpresion)

if (TipoAccion c O) TipoAccion *= -1 ;

strcpy(CadExpresion,""); switch (TipoAccion)

case Cod-SELECT : strcpy(CadExpresion,"SELECT");break; case Cod-DELETE : strcpy(CadExpresion,"DELETE");break; case Cod-UPDATE : strcpy(CadExpresior1,"UPDATE");break; case Cod-TABLE : strcpy(CadExpresion,"TABLE");break; case Cod-INSERT : strcpy(CadExpresion,"INSERT");break;

1;

yyerroro char CadExpresion[80];

fclose(Expansion); fclose(Codigo); fclose(yyin); ObtenExpresion(CadExpresion); printf("ERR0R DE SINTAXIS EN EXPRESION %S , LINEA: %d\n",CadExpresion,yylineno); exit(0);

1

UAM 37

void IniciaListas(void) int Ap;

ListaVars = ListaAsig = ListaAtrib = ListaColurn = NULL; for (Ap=O;Ap < MAXCURSOR;++Ap)

Cursor[Ap][l] = Cursor[Ap][O] = NULL; 1

main0 char NombreArch[Maximo],ArchCod[Maximo],ArchExpansion[Maxirno];

IniciaListaso; strcpy(NombreArch,"Rep-D0c.c"); CapturaNombreArch(NombreArch,ArchCocl,ArchExpansion); if (yyin !=NULL)

YYParseO: fclose(Expansion); fclose(Codigo); printf("\nOK. ARCHIVOS CREADOS : %)S , %S \n",ArchCod,ArchExpansion);

1

UAM 38

I*

ARCHIVO : btrv.c

*I

............................................................................................................................................ ............................................................................................................................................

............................................................................................................................................ ............................................................................................................................................

/* Banderas de llaves *I #define DUPLICADO 1 #define MODIFICABLE 2 #define BINAR10 4 #define NULOS 8 Mefine SEGMENTADO 16 #define ALT-COL-SEQ 32 #define DESCENDIENTE 64 ##define SUPLEMENTO 128 #define TIPO-EXTENDIDO 256 #define MANUAL 51 2

/* Funciones de BTRIEVE */

#define OPEN O #define CLOSE 1 #define INSERT 2 #define UPDATE 3 #define DELETE 4 #define GET-EQUAL 5 #define GET-NEXT 6 #define GET-PREVIOUS 7 #define GET-GREATER 8 #define GET-GREATER-OR-EQUAL 9 #define GET-LESS-THAN 10 #define GET-LESS-THAN-OR-EQUAL 11 #define GET-FIRST 12 #define GET-LAST 13 #define CREATE 14 #define STAT 15 #define EXTEND 16 ##define SET-DIRECTORY 17 #define GET-DIRECTORY 18 #define BEGIN-TRANSACTION 19 #define END-TRANSACTION 20 #define ABORT-TRANSACTION 21 #define GET-POSITION 22 ##define GET-DIRECT 23 #define STEP-NEXT 24 #define STOP 25 #define VERSION 26 #define UNLOCK 27 #define RESET 28 #define SET-OWNER 29 #define CLEAR-OWNER 30 #define STEP-FIRST 33 #define STEP-LAST 34

UAM 39

#define STEP-PREVIOUS 35

I* Banderas de archivos *I #define Long-Variable 1 #define Trunc-Blancos 2 Mefine Prealocacion 4 #define Compresion 8 #define Solo-Llaves 16 Mefine Libre-I O 64 #define Libre-20 128 #define Libre-30 192

I* Tipos de datos extendidos *I

##define STRING 0 #define STRINGDATE -1 #define INTEGER 1 Mefine FLOAT 2 Mefine DATE 3 #define TIME 4 Mefine DECIMAL 5 #define MONEY 6 #define BOOLEAN 7 #define NUMERIC 8 Mefine BFLOAT 9 #define LSTRING 10 #define ZSTRING 11 #define U-BINARY 14 #define AUTOINCR 15

struct Especific-Llave

int Pos-Llave, Long-Llave, Bandera-Llave;

char NoUsado[4], Tipo-Llave, Reservado[S];

1;

struct Espec-Archivo

int Long-Reg, Tam-Pag, Num-Indices;

char No_Usado[4]; int Arch-Bandera; char Reservado[2]; int Prealoc; struct Especific-Llave Llaves[20];

1;

UAM 40

void ErrorBtrieve(int TipoError,int NumLinea) char ErrorT[lOO];

strcpy(ErrorT,""); switch(TipoError)

case 3 : strcpy(ErrorT,"TABLA NO AB1ERTA");break; case 5 : strcpy(ErrorT,"LA LLAVE NO PERMITE DUPLICAD0S");break; case 9 : strcpy(ErrorT,"TABlA VAClA O SI: LLEGO AL F1NAL");break; case 12 : strcpy(ErrorT,"TABLA NO AB1ERTA);break; case 18 : strcpy(ErrorT,"DISCO LLEN0");break; case 20 : strcpy(ErrorT,"BTRIEVE NO CARGAD0");break; case 28 : strcpy(ErrorT,"TAMAYO DE REGIISTRO INVALIDO"); case 29 : strcpy(ErrorT,"LLAVE DEMASIADO GRANDE (MAX. 255 BYTES)");break; case 45 : strcpy(ErrorT,"DECLARAClON INCONSISTENTE DE LLAVE MULT1PLE");break; case 59 : strcpy(ErrorT,"YA EXISTE LA TA13LA");break;

1 printf("ERR0R %d, %S EN LINEA %d\n",TipoError,ErrorT,NumLinea); exit(TipoError);

1

UAM 41

/*

Archivo : uti1.c

*I

............................................................................................................................................... ...............................................................................................................................................

............................................................................................................................................... ...............................................................................................................................................

#include "define.c"

struct Lista-Ids *ListaColum,*ListaVars,*ListaAsig,*ListaAtrib;

struct RegldNum *ListaldNum;

/*Lista de campos definidos por el usuario.*/ struct CamposF1 *Listacampos;

int TipoAccion,Seccion,CapturaElem,NumEle~~s,WHERE,Secc-lNTO,

char NomColumna[33],*Tabla,*Orden,*Cad~Aux,*ldent,*CadWhere,*ArchTempo,*Variable, LineaActual,LineaActual2,DECLARE,NumCampos;

*LlamadaDb,*CampoCap,*DeclDatos,*Limpiar,*CadLlenaVars,*lnicializar, *LlamadaAmbienta;

char *ErrorTexto[] = ("FALTA DE MEMORIA DINAMICA", "DEBE DEFINIRSE EL NUMERO DE CAMFOS", "DEBE DECLARARSE LA ESTRUCTURA DE LA TABLA, O NOMBRE INCORRECTO", "NO PUEDE HABER MAS DE UN CURSOR DECLARADO CON EL MISMO NOMBRE", "NUMERO DE CAMPO ERRONEO", "NO SE HA DECLARADO EL CURSOR, O NOMBRE INCORRECTO", "ATRIBUTO INVALID0 EN FUNCION INPUT", "NOMBRE DE CAMPO ERRONEO O INEXISTENTE" 1;

void Escribe(char *Mensaje)

printf("%s\n",Mensaje);

1

void EscribeM(char *Mensaje,char *Mensaje2)

printf("%s",Mensaje); Escribe(Mensaje2);

1

struct RegldNum *EstaDefinida(char *Ta struct RegldNum *Aux;

Aux = ListaldNum;

IblaAux)

while ((Aux != NULL) && (strcmp(Aux -> Ident,TablaAux) != O))

return(Aux); Aux = Aux -> Liga;

1

UAM 42

int POS(char Caracter,char *Cadena) char *Lugar;int Result;

Lugar = strchr(Cadena,Caracter); Result = (int) (Lugar - Cadena); if (Lugar != NULL)

return(Resu1t); else

return(-1); 1

void printsm(F1LE **SALIDA,char *Mensaje,int Puntocoma) int Ap=O;char Carac;

if ( (strlen(Mensaje)) > O)

while ((Carac = Mensaje[Ap]) != 'k0')

if ( (Carac) != '@I)

++Ap; putc(Carac,*SALIDA);

1 if (Puntocoma == 1)

else fprintf(Codigo,";\n");

fprintf(Codigo,"\n"); 1

1

void Error(int TipoError)

switch(TipoError) c

case MEMORIA : Escribe(ErrorTexto[lVIEMORlA]);break; case NUMCAMPOS : Escribe(ErrorTexto[NUMCAMPOS]);break; case NOMTABLA : Escribe(ErrorTexto[NOMTABLA]);break; case CURSORDUPL : Escribe(ErrorTexto[CURSORDUPL]);break; case NUMCAMPO : Escribe(ErrorTextc~[NUMCAMPO]);break; case NOEXISTECURSOR : Escribe(ErrorTexto[NOEXISTECURSOR]);break; case ATRIBUTODESC : Escribe(ErrorTe:do[ATRIBUTODESC]);break; case NOMCAMPO : Escribe(ErrorTexto[NOMCAMPO]);break;

1 fflush(Expansi0n); fflush(Codigo); fclose(Expansion); fclose(Codigo); printf("L1NEA: %d %S \n",yylineno,yytext); exit(TipoError);

1

UAM 43

void FormateaCad(char buffer[200],char fmt[2010], ...) va-list argptr;char BUFFER[200];

va-start(argptr, fmt); if (vsprintf(BUFFER, fmt, argptr) > 200)

Error(MEM0RIA); strcpy(buffer,BUFFER); va-end(argptr);

I

void FormaNombreFuncion(char *NomFuncion,int NumLinea,char *Result) char CadAux[lOO]; FormateaCad(CadAux,"%s%d",NomFuncion,NumLinea); strcpy(Result,CadAux);

I

void FormaLlamada(char *CadAux,char *Pararnetro,char *NomFuncion,int NumLinea) char CadParametro[80],CadNum[lO];

itoa(NumLinea,CadNum,lO); if (strcmp(Parametro,"") != O)

FormateaCad(CadParametro,"&%s,%s);\n",Parametro,CadNum); else

FormateaCad(CadParametro,"%s);\n",CaldNum); LlamadaDb = (char *) malloc(80); FormaNombreFuncion(CadAux,NumLinea,LlamadaDb); FormateaCad(LlamadaDb,"%s%s(%s",llama~daDb,&NomFuncion[l],CadParametro);

I

void QuitaCornillas(char *Fuente,char *Destino) char CadAux[Caracteres];int Long; strcpy(CadAux,&Fuente[2]); Long = strlen(CadAux) - 1; strcpy(Destino,""); strncpy(Destino,CadAux,Long); Destino[Long] = '&O';

I

void QuitaMarcas(char *Cadena) char *Pos;

while ((Pos = strchr(Cadena,'@')) != NULL) strcpy(Pos,Pos+l);

I

void ArmaCampoN(char *NomTabla,char *Registro,int NumCampojnt TipoSelector,char *CampoSalida) struct CarnposFl *Aux;int Ap=l;char CarnpoA.ux[SO];

Aux = Listacampos; while ((Aux != NULL) && (strcmp(Aux -> NornbreTabla,NomTabla) != O))

Aux = Aux -> Liga; while ((Aux != NULL) && (Ap < NumCampo):)

UAM 44

Aux = Aux -> Liga;

Error(NUMCAMP0);

if (Aux == NULL)

else

if (Aux -> Tipolndice != STRING)

else

strcat(CampoSalida,Registro); if (TipoSelector == Cod-flecha)

strcat(CampoSalida,"->"); else

strcat(CampoSalida,"."); QuitaComillas(Aux -> NombreCampo,CampoAux); strcat(CampoSalida,CampoAux); if (Aux -> Tipolndice != STRING)

strcpy(CampoSalida,"(char *) a(");

strcpy(CampoSalida,"(char *)");

strcat(CampoSalida,")"); 1

1

int RegresaNum(char *CadNum) int NumAux;

NumAux = atoi(CadNum); return(NumAux);

1

char *RegresaMem(int Longitud,char *Cadlnic,int Separar) char *CadRet;

CadRet = (char *) malloc(Longitud + 2); if (CadRet == NULL)

Error(MEM0RIA); if (Cadlnic[O] != 'a')

strcpy(CadRet,"@"); else

strcpy(CadRet,""); if (Separar == TRUE) strcat(CadRet," ");

strcat(CadRet,Cadlnic); return(CadRet);

1

char *RegresaApCad(char *CadenaAux) char *Regreso;int Longitud;

Longitud = strlen(CadenaAux) + 2; Regreso = RegresaMem(Longitud,CadenaAux,FALSE); return(Regres0);

1

UAM 45

void FormaLlamadaLib(char *buffer,char *fmt, , ..) va-list argptrphar BUFFER[501];

va-start(argptr, fmt); if (vsprintf(BUFFER, fmt, argptr) > 500)

Error(MEM0RIA); buffer = RegresaApCad(BUFFER); va-end(argptr);

1

void ObtenListaTrabajo(int NumLista,struct Lista-Ids **ListaTrb)

switch(NumLista)

case COLUMNAS : (*ListaTrb) = ListaColum; break ; case INTO : (*ListaTrb) = ListaVars; break ; case ASIGNACION: (*ListaTrb) = ListaAsig; break ; case ATRIBUTOS : (*ListaTrb) = ListaAtrib'; break ;

I I

void RegresaListaTrabajo(int NumLista,struct I-ista-Ids **ListaTrb)

switch(NumLista)

case COLUMNAS : ListaColum = (*Listal'rb) ; break ; case INTO : ListaVars = (*ListaTrb) ; break ; case ASIGNACION : ListaAsig = (*ListaTrb) ; break ; case ATRIBUTOS : ListaAtrib = (*ListaTrb) ; break ;

1 I

void LiberaCad(char *CadenaBasura)

if (CadenaBasura[O] == 'a') free((void *) CadenaBasura); CadenaBasura = NULL;

1 I

void VaciaLista(struct Lista-Ids **Lista) struct Lista-Ids *Aborrar;char *ApCad;

while ((*Lista) != NULL)

Aborrar = (*Lista); (*Lista) = (*Lista) -> Liga; ApCad = Aborrar -> Ident; Aborrar -> ldent = NULL; free((void *) Aborrar); LiberaCad(ApCad);

UAM 46

void ObtenUltimo(struct Lista-Ids *Lista,struct I-ista-Ids **Ultimo)

(*Ultimo) = Lista; while ((*Ultimo) -> Liga != NULL)

(*Ultimo) = (*Ultimo) -> Liga; 1

void CreaNodo(struct Lista-Ids **Nodo,char *Token)

(*Nodo) = (struct Lista-Ids *) malloc(sizeof(s1,ruct Lista-Ids)); (*Nodo) -> ldent = RegresaApCadCToken); (*Nodo) -> Liga = NULL; if ( (*Nodo) == NULL)

Error(MEM0RIA); 1

void Agrega-A-Lista(int CodSeccion,char *Token) struct Lista-Ids *Ultimo,*Listalnsercion,*NodoAux;

if (CodSeccion != O) ObtenListaTrabajo(CodSeccion,&Listalnsercion); if (Listalnsercion == NULL)

CreaNodo(&Listalnsercion,Token); RegresaListaTrabajo(CodSeccion,&ListaInsercion);

1 else

ObtenUltimo(Listalnsercion,&Ultimo); CreaNodo(&NodoAux,Token); Ultimo -> Liga = NodoAux; Ultimo = NodoAux:

void ImprimeLista(char *Mensaje,int NumListar) struct Lista-Ids *Aux; ObtenListaTrabajo(NumLista,&Aux); Escribe(Mensaje); while (Aux != NULL)

printf("%s\n",Aux -> Ident); Aux = Aux -> Liga;

1 1

UAM 47

void VaciarListaCod(int Codigo) struct Lista-Ids *ListaTrb; ObtenListaTrabajo(Codigo,&ListaTrb); VaciaLista(&ListaTrb); RegresaListaTrabajo(Codigo,&ListaTrb);

1

void Encabezado(void)

Section = O; fprintf(Codigo,"#include \"turcbtrv.c\"\n"); fprintf(Codigo,"#include <stdio.h>\n"); fprintf(Codigo,"#include <string.h>\n"); fprintf(Codigo,"#include <stdlib.h>\n"); fprintf(Codigo,"#include \"biblio.c\"\n"); fprintf(Codigo,"#include \"sayget.c\"\n"); fprintf(Codigo,"#include \"%s\"\n",CODIGO);

1

void ConcatenaSinMarca(char *CadDestino,char *CadOrigen)

strcat(CadDestino," "); if (CadOrigen[O] == '@I)

else strcat(CadDestino,&CadOrigen[l]);

strcat(CadDestino,CadOrigen); 1

void CopiaSinMarca(char *CadDestino,char *Ciadorigen)

if (CadOrigen[O] == 'a') else strcpy(CadDestino,&CadOrigen[l]);

strcat(CadDestino,CadOrigen); 1

UAM 48

char *EntreParent(char *CadAux) int Longitudphar *ApCad;

Longitud = 3 + strlen(CadAux); ApCad = RegresaMem(Longitud,"(",FALSE); ConcatenaSinMarca(ApCad,CadAux); strcat(ApCad,")"); LiberaCad(CadAux); return(ApCad);

char *CadcomaCad(char *Cad1 ,char *Cad2) (char *ApCad;int Longitud;

Longitud = 3 + strlen(Cad1) + strlen(Cad2); ApCad = RegresaMem(Longitud,Cadl ,FALSE); strcat(ApCad,","); ConcatenaSinMarca(ApCad,CadZ); LiberaCad(Cad1); LiberaCad(Cad2); retum(ApCad);

1

char *EntreCorch(char *CadAux) int Longitud;char *ApCad;

Longitud = 3 + strlen(CadAux); ApCad = RegresaMem(Longitud,"[",FALSE); ConcatenaSinMarca(ApCad,CadAux); strcat(ApCad,"]"); LiberaCad(CadAux); return(ApCad);

1

char *EntreLlaves(char *CadAux) int Longitud;char *ApCad;

Longitud = 3 + strlen(CadAux); ApCad = RegresaMem(Longitud,"(",FALSE); ConcatenaSinMarca(ApCad,CadAux); strcat(ApCad,")"); LiberaCad(CadAux); return(ApCad);

1

UAM 49

void LiberaCads(char *Cad1 ,char *Cad2,int Libera)

if (Libera > O)

if (Libera == 3)

LiberaCad(Cad1); LiberaCad(Cad2);

1

else

switch(Libera) case 1 : LiberaCad(Cad1);break; case 2 : LiberaCad(Cad2);break;

1 1

1 1

char *UneCads(char *Cad1 ,char *Cad2,int Libera) char *ApCad;int Longitud;

Longitud = strlen(Cad1) + strlen(Cad2) + 2; ApCad = RegresaMern(Longitud,Cadl ,TRUE!); ConcatenaSinMarca(ApCad,Cad2); LiberaCads(Cad1 ,Cad2,Libera); return(ApCad);

1

void IniciaSelect(void)

VaciarListaCod(lNT0); VaciarListaCod(C0LUMNAS);

1

void Condiciones(void)

1 EscribeM("Condicion: ",Cadwhere);

void ArchivoTernpo(void)

1 EscribeM("ArchivoTetnpora1: ",ArchTempo),

UAM 50

int EsCampoDeTabla(char *Campo) struct CamposFl *Aux;int Pertenece;char CampoAux[20]; FormateaCad(CampoAux,"@Y%s\"",Campo); Aux = Listacampos; Pertenece = FALSE; while ((Aux != NULL) && (Pertenece == FAL.SE))

if (strcmp(Aux ->NombreTabla,Tabla) == O)

if (strcmp(Aux -> NombreCampo,CampoAux) == O)

Pertenece = TRUE; I Aux = Aux -> Liga;

I return(Pertenece);

I

char *AgregaTabla(char *Campo) char CadAux[SO];char *Result;

if (EsCampoDeTabla(Campo) == TRUE)

else

Result = RegresaApCad(CadAux); return(Resu1t);

FormateaCad(CadAux,"_V_%s.%s",&Tabla[l],Campo);

strcpy(CadAux,Campo);

1

int Estalndexada(char *NomTabla) (struct CamposFl *Aux;int Result;

Result = FALSE; Aux = Listacampos; while (Aux != NULL)

if ((strcmp(Aux -> NombreTabla,NomTabla) == O) && (Aux -> Tipolndice != NO))

Result = TRUE; break;

1 Aux = Aux -> Liga;

I return(Resu1t);

1

void ObtenCadOperacion(char *Operacion,char *Siguiente)

if (Estalndexada(Tab1a) == TRUE) strcpy(Operacion,"GET-FIRST"); strcpy(Siguiente,"GET-NEXT");

I

else

UAM 51

strcpy(Operacion,"STEP-FIRST"); strcpy(Siguiente,"STEP-NEXT");

1 1

void EscribeSELECT(int NumLinea,char *-TablaAux) char Parametro[6O],NombreTabla[30],NomFur~cion[3O];char Operacion[2O],Siguiente[20];

strcpy(NombreTabla,"_V_"); strcat(NombreTabla,&-TablaAux[l]); ObtenCadOperacion(Operacion,Siguiente); if (Secc-INTO == TRUE)

strcpy(Parametro,"struct -"); strcat(Parametro,&-TablaAux[l]); strcat(Parametro," *-Tabla-Aux"); strcat(Parametro,","); ForrnaLlarnada("_SELECT~",Variable,~TabIaAux,NumLinea);

1 else

strcpy(Parametro,""); FormaLlamada("_SELECT~","",~TablaAux,NumLinea);

FormaNombreFuncion("_SELECT_",NumLinea,NomFuncion); fprintf(Expansion,"\nvoid %s%s(%sint NumLinea)\n(",NomFuncion,&~TablaAux[l],Parametro); fprintf(Expansion,"int -STATUS,Ap,Longitud;char BufLlave[lOO];"); fprintf(Expansion,"struct -%S %s;",&-TablaP.ux[l],NombreTabla); if (Secc-INTO == TRUE)

fprintf(Expansion,"\n Longitud = sizeof(%s);\n",NombreTabla); fprintf(Expansion," Ap = ObtenBuffer(\"~%s\",NumLinea);\n",&~TablaAux[l]); fprintf(Expansion," -STATUS=BTRV(%s,ListaBuf[Ap].BUFFER,

(char *) &%s,&Longitud,BufLlave,O);\n",Operacion,NombreTabla); fprintf(Expansion," if (-STATUS != O) ErrorBtrieveCSTATUS,NumLinea);\n"); fprintf(Expansion," -FOUND- = 1 ;"); fprintf(Expansion," while (-STATUS == O)\II"); fprintf(Expansion," \n"); if (WHERE == TRUE)

1

fprintf(Expansion,"int -Ap=O;");

fprintf(Expansion," if "); printsm(&Expansion,CadWhere,O); fprintf(Expansion,"\n"); fprintf(Expansion," \n"); if (Secc-INTO == TRUE) fprintf(Expansion," ++-Ap;\n"); fprintf(Expansion," if (-Ap > 1) ElrrorT(VARIOSREGISTROS,%d);\n",LineaActual); fprintf(Expansion," Tabla-Aux = -V-FECHA;\n",&Variable[l]);

1 -

fprintf(Expansion," \n"); 1

fprintf(Expansion," -STATUS=BTRV(%s,ListaBuf[Ap].BUFFER,

fprintf(Expansion," \n\n\n\n"); (char *) &%s,&Longitud,BufLlave,O);\n",Siguiente,NombreTabla);

1

UAM 52

void FinalizaSelect(void)

VaciarListaCod(lNT0); VaciarListaCod(C0LUMNAS); LiberaCadUabla); LiberaCad(0rden); LiberaCad(CadWhere); LiberaCad(ArchTemp0); LiberaCad(Variab1e); WHERE = FALSE; Secc-INTO = FALSE; LineaActual = -1 ;

1

void ObtenParametro(char *Accion,char *Parametro,char *-TablaAux)

if (strcmp(Accion,"UPDATE") == O)

else FormateaCad(Parametro,"struct -%S *-Tabla-Aux",&-TablaAux[l]);

strcpy(Parametr0,"");

void EscribeDELETE(int NumLinea,char *-TablaAux) char NombreFuncion[60],CampoSig[60],0peracion[20],S~gu~ente[20],NombreTabla[30];

FormaLlamada("~DELETE_","",JablaAux,~lumLinea); ObtenCadOperacion(Operacion,Siguiente); strcpy(NombreTabla,"-V-'I); strcat(NombreTabla,&-TablaAux[l]); ArmaCampoNCTablaAux,NombreTabla,l ,Cod-punto,CampoSig); Fom7aNombreFuncion("_DELETE_",NumLir~ea,NombreFuncion); fprintf(Expansion,"\nvoid %s%s(int NumLinea)\n(",NombreFuncion,&-TablaAux[l]); fprintf(Expansion,"int -STATUS,Ap,Longitud;"); fprintf(Expansion,"struct -%S %s;\n",&-TablaAux[l],NombreTabla); fprintf(Expansion," Longitud = sizeof(struct -%s);\n",&_TablaAux[l]); fprintf(Expansion," Ap = ObtenBuffer(\"~%s\",NumLinea);\n",&~TablaAux[l]); fprintf(Expansion," -STATUS=BTRV(%s,ListaBuf[Ap].BUFFER,

fprintf(Expansion," if CSTATUS != O) ErrorBtrieveCSTATUS,NumLinea);\n"); fprintf(Expansion," while CSTATUS == O)\n"); fprintf(Expansion," \n"); if (WHERE == TRUE)

(char *) &%s,&Longitud,%s,O);\n",Operacion,NombreTabla,CampoSig);

fprintf(Expansion," if "); printsm(&Expansion,CadWhere,O); fprintf(Expansion,"\n"); fprintf(Expansion," ");

1 fprintf(Expansion," -STATUS=BTRV(DELETE,ListaBuf[Ap].BUFFER,

(char *) &%s,&Longitud,%s,O);\n",NombreTabla,CampoSig); fprintf(Expansion," if CSTATUS != O) ErrorBtrieveCSTATUS,NumLinea);\n");

UAM 53

fprintf(Expansion," -STATUS=BTRV(%s,L.istaBuf[Ap].BUFFER,

fprintf(Expansion," \n\n\n\n"); (char *) &%s,&Longitud,%s,O);\n",Siguiente,NombreTabla,CampoSig);

1

void FinalizaDELETE(void) Liberacadflabla); LiberaCad(CadWhere); WHERE = FALSE; Seccion = O;

1

void EscribeUPDATE(int NumLinea,char *-TablaAux) char NombreFuncion[6O],Parametro[6O],Campo1[6O],CampolAux[60],0peracion[20],Siguiente[20],No mbreTabla[30]; FormaLlamada("_UPDATE~",&Variable[l],_'TablaAux,NumLinea); ObtenCadOperacion(Operacion,Siguiente); ArmaCampoNCTablaAux,"-Tabla-Aux",l ,Cod-flecha,Campol); FormateaCad(NombreTabla,"-V-%s",&Tabla[l]); ArmaCampoN(Tabla,NombreTabla,l ,Cod-punto,CampolAux); FormateaCad(Parametro,"struct -%S -Tabla-Aux*",&-TablaAux[l]); FormaNombreFuncion("_UPDATE_",NumLi~~ea,NombreFuncion); fprintf(Expansion,"\nvoid %s%s(%s,int

fprintf(Expansion,"int -STATUS,Ap,Longitudl;"); fprintf(Expansion,"struct -%S %s;\n",&-TablaAux[1],NombreTabla); fprintf(Expansion," Longitud = sizeof(struct -%s);\n",&-TablaAux[l]); fprintf(Expansion," Ap = ObtenBuffer(\"~%s\",NumLinea);\n",&~TablaAux[l]); fprintf(Expansion," STATUS=BTRV(%s,LilstaBuf[Ap].BUFFER,(char *)

fprintf(Expansion," if (-STATUS != O) Errol-BtrieveCSTATUS,NumLinea);\n"); fprintf(Expansion," while (-STATUS == O)\n"); fprintf(Expansion," \n"); if (WHERE == TRUE)

NumLinea)\n(",NombreFuncion,&-TablaAux[l],Parametro);

&%s,&Longitud,ListaB~f[Ap].BUFFER,O);\n~~,C~peracion,NombreTabla);

fprintf(Expansion," if "); printsm(&Expansion,CadWhere,O); fprintf(Expansion,"\n"); fprintf(Expansion," ");

1 fprintf(Expansion," STATUS=BTRV(UPDATE,ListaBuf[Ap].BUFFER,(char *)

fprintf(Expansion," if (-STATUS != O) ErrorBtrieveCSTATUS,NumLinea);\n"); fprintf(Expansion," STATUS=BTRV(%st,ListaBuf[Ap].BUFFER,(char *)

fprintf(Expansion," \n\n\n\n");

- Tabla-Aux,&Longitud,%s,O);\n",Campol);

&%s,&Longitud,%s,O);\n~Siguiente,NombreT;3bla,CampolAux);

1

UAM 54

void FinaIizaUpdate(void)

LiberaCadUabla); VaciarListaCod(ASIGNACl0N);

1

char *AsignacionCond(ApCadena) char *ApCadena;

if (Seccion != O)

else return(ApCadena);

LiberaCad(ApCadena); return(NULL);

1 1

char *RegresaAscii(char Valor) char VaIAux[2];

strcpy(VaIAux," "); ValAux[O] = Valor; return(RegresaApCad(Va1Aux));

1

int INT(char *CadAux) char ValAux;

ValAux = CadAux[l]; return(Va1Aux);

1

void CreaNodoCampos(struct CamposFl **Nodo,char *NomTabla,char *Nombre,int TipoDatosEx,

int Longitudjnt Tipolndice,int Tipovalor)

(*Nodo) = (struct CamposFl *) malloc(sizeof(struct CamposFl)); if ( (*Nodo) == NULL)

Error(MEM0RIA); (*Nodo) -> Nombrecampo = Nombre; (*Nodo) -> NombreTabla = RegresaApCad(NomTab1a); (*Nodo) -> TipoDato = TipoDatosEx; (*Nodo) -> Longitud = Longitud; (*Nodo) -> Tipolndice = Tipolndice; (*Nodo) -> Tipovalor = Tipovalor; (*Nodo) -> Liga = NULL;

55

void ObtenUltimoCampo(struct CamposFl *Lista,struct CamposFl **Ultimo)



void ObtenLongitud(int TipoDato,char *ExprPrim,int *Longitud)

switch(TipoDato)

case STRING : *Longitud = RegresaNum(&ExprPrim[l]);break; case INTEGER : *Longitud = 2;break; case FLOAT : *Longitud = 4;break; case DATE : *Longitud = 4;break; case TIME : *Longitud = 4;break; case DECIMAL : *Longitud = RegresaNum(&ExprPrim[l]);break; case BOOLEAN : *Longitud = 2;break; case NUMERIC : *Longitud = RegresaNurn(&ExprPrim[l]);break; case LSTRING : *Longitud = RegresaNum(&ExprPrim[l]);break; case ZSTRING : *Longitud = RegresaNum(&ExprPrim[l]);break; case AUTOINCR : *Longitud = 4;break;

1 1

void ObtenPrimerCarnpo(char *NomTabla,struct CamposFl **Primercampo) struct CamposFl *Aux,*Anterior;

Aux = Listacampos; Anterior = Aux; while ((Aux != NULL) && (strcmp(Aux -> NombreTabla,NomTabla) != O))

Anterior = Aux; Aux = Aux -> Liga; 1

*Primercampo = NULL:

*Primercampo = Anterior;

if (*Primercampo == Listacampos)

else

1

UAM 56

void BuscaPosCampo(struct CamposFl *NodoAux,struct CamposFl *Listacampos,

struct CamposFl *Aux,*Siguiente;int Salir; struct CamposFl *PrimerCampo,struct CamposFl **PosNodo)

if (Listacampos == NULL)

else

*PosNodo = NULL;

if (NodoAux -> Tipolndice == NO)

else ObtenUltimoCampo(ListaCampos,PosNodo);

if (PrimerCampo == NULL)

else *PosNodo = NULL;

Aux = PrimerCampo; Salir = FALSE; while (Salir == FALSE)

Siguiente = Aux -> Liga; if ((Siguiente == NULL) ( 1 (Siguiente -> Tipolndice == NO))

*PosNodo = Aux; Salir = TRUE;

1 Aux = Aux -> Liga;

1 if ((*PosNodo == Listacampos) && ((*PosNodo) -> Tipolndice == NO)) *PosNodo = NULL;

1 1

1 1

void InsertaNodoCampo(struct CamposFl *NodoAux,struct CamposFl **ListaCampos,char *NomTabla) struct CamposFl *PosNodo,*PrimerCampo,*,4ux; ObtenPrimerCampo(NomTabla,&PrimerCampo); BuscaPosCampo(NodoAux,*ListaCampos,PrimerCampo,&PosNodo); if (PosNodo == NULL)

if (*Listacampos == NULL)

else *Listacampos = NodoAux;

NodoAux -> Liga = *Listacampos; *Listacampos = NodoAux;

1 1

else

if (PosNodo -> Liga == NULL) PosNodo -> Liga = NodoAux;

else

57

Aux = PosNodo -> Liga; PosNodo -> Liga = NodoAux; NodoAux -> Liga = Aux;

void Agrega-A-ListaCampos(char *NomTabla.char *NomCampo,int TipoDatoEx,char *ExprPrim,int Tipolndice,int Tipovalor) struct CamposFl *NodoAux;int Longitud; ObtenLongitud(TipoDatoEx,ExprPrirn,&Longitud); if (Listacampos == NULL)

CreaNodoCampos(&ListaCampos,NomTabla,NomCampo,TipoDatoEx,Longi~ud,Tipolndice, Tipovalor);

else CreaNodoCampos(&NodoAux,NomTabla,NomCampo,TipoDatoEx, Longitud,Tipolndice,TipoValor); strcpy(NodoAux -> NombreCampo,NornlCampo); InsertaNodoCampo(NodoAux,&ListaCampos,NomTabla);

1 1

void IniciaCapturaTABLE(void)

1 Section = Cod-TABLE;

void BuscaInicioTabla(struct CarnposFl **Aux,char *-TablaAW

while ( ((*Aux) != NULL) && (strcmp((*Aux) ..>NombreTabla,_TablaAux) != 0) ) (*Aux) = (*Aux) -> Liga;

1

void ImprimeCampo(int ClaveTipo,char *NombreCampo,int Longitud)

switch(C1aveTipo)

case INTEGER : fprintf(Expansion," irlt %s;",NombreCampo);break; case STRING : fprintf(Expansion," char %s[%d];",NombreCampo,Longitud);break; case STRINGDATE : fprintf(Expansion," char %s[lO];",NombreCampo);break; case FLOAT : fprintf(Expansion," float %s[lO];",NombreCampo);break; case BOOLEAN : fprintf(Expansion," char %s",NombreCampo);break;

1 fprintf(Expansion,"\n");

1

UAM 58

void Escribe-TABLE(void) struct CamposFl *Aux;char CampoAux[Caracteres];

Aux = Listacampos; BuscalnicioTabla(&Aux,Tabla); fprintf(Expansion,"struct -%s\nfln",&Tabla[l]); while ( (Aux != NULL) && (strcmp(Aux->NornbreTabla,Tabla) == O) )

QuitaComillas(Aux -> NombreCampo,CampoAux); ImprimeCampo(Aux->TipoDato,CampoAux,Aux -> Longitud); Aux = Aux -> Liga;

1 fprintf(Expansion,";\n\n\n");

1

char *ExpandeTABLE(char *TablaAux) char *Result,*ApAux,Structure[50];

ApAux = RegresaApCadCTablaAux); if ((EstaDefinida(ApAux)) != NULL)

FormateaCad(Structure,"struct -%S ",TablaAux); Result = RegresaApCad(Structure);

1 else

free((void *) ApAux); return(Resu1t);

Error(N0MTABLA);

1

void MuestraDatosTable(void) struct RegldNum *ListaAux;

ListaAux = ListaldNum; while (ListaAux != NULL)

printf("TABLE: %S , %d\n",ListaAux->ldent,ListaAux -> NumElems); ListaAux = ListaAux -> Liga;

1 1

void ObtenUltimoldNum(struct RegldNum *Li:sta,struct RegldNum **Ultimo)



UAM 59

void CreaNodoldNum(struct RegldNum **Nodol,char *Token,int Numero)

(*Nodo) = (struct RegldNum *) malloc(sizeof(struct RegldNum)); (*Nodo) -> ldent = RegresaApCadCToken); (*Nodo) -> NumElems = Numero; (*Nodo) -> Liga = NULL; if ( (*Nodo) == NULL)

Error(MEMOR1A); 1

/*Guarda los nombres de las tablas asi como el numero de campos que tiene.*/ void AgregaAListaldNum(char *IdentNum,int Nlumero) struct RegldNum *NodoAux,*Ultimo;

if (ListaldNum == NULL)

else

CreaNodoldNum(&ListaIdNum,ldentNurn,Numero);

ObtenUltimoldNum(ListaldNum,&Ultirno); CreaNodoldNum(&NodoAux,ldentNunl,Numero); Ultimo -> Liga = NodoAux; Ultimo = NodoAux;

1 1

void CalcNumLlavesCampos(char *NomTabla,int *NumLlaves,int *NumCampos) struct CamposFl *Aux;

Aux = Listacampos; *NumLlaves = *NumCarnpos = O ; do

if (strcmp(Aux->NombreTabla,NomTabla) == O)

if (Aux -> Tipolndice != NO) ++(*NumLlaves);

++(*NumCampos); 1

Aux = Aux -> Liga; while (Aux != NULL);

1

void Escribe-Llaves(char *-TablaAux) struct CamposFl *Aux,*Siguiente;int PosLlave,IndiceReg,BanderaLI,TipoDato;

Aux = Listacampos; IndiceReg = O ; PosLlave = 1 ; while (Aux != NULL)

if (strcmp(Aux ->NombreTabla,-TablaAux) == O)

if (Aux -> Tipolndice != NO)

Siguiente = Aux -> Liga; if ((Siguiente != NULL) && (strcmp(Siguiente->NombreTabla,-TablaAux) == O) &&

(Siguiente -> Tipolndice != NO))

UAM 60

BanderaLl = SEGMENTADO;

BanderaLl = O;

TipoDato = STRING;

else

if ((TipoDato = Aux -> TipoDato) == STRINGDATE)

BanderaLl += Aux -> Tipolndice + Aux -> Tipovalor + TIPO-EXTENDIDO +

fprintf(Expansion, MODIFICABLE;

" Llena~Espec~Llave(&RegArchivo.Llaves[%d],~~d,%d,%d,~/~d);\n", IndiceReg,PosLlave,Aux->Longitud,BanderaLi,TipoDato);

++lndiceReg; 1

PosLlave += Aux -> Longitud; 1

Aux = Aux -> Liga;

I* Longitud = Longitud de la estructura en C , incluye llaves y datos. TamPag = Es el tamano optimo de la pagina para que se ocupe la mayor parte

Numlndices = Es el numero de campos que st? definieron en la estructura

ArchBandera = Definicion para el archivo. Prealoc = Especifica si se va a hacer prealocacion. *I

de datos .

TABLE.

void EscribeCREATE(int NumLinea,char *Extension,int Verificar,char *-TablaAux,char *NomArchivo) int ArchBandera,Prealoc,NumLlaves,NumCamposer,NumLlavesAux; char NomArch[l5],NomFuncion[30]; CalcNumLlavesCampos~TablaAux,&NumLlaves,&NumCampos); if (NumLlaves > O )

else

ArchBandera = Prealocacion + Libre-20; Prealoc = 5; FormaLlamada("~CREATE_","",NomArchivo,NumLinea); ForrnaNombreFuncion("_CREATE-",NumLinea,NomFuncion); fprintf(Expansion,"\nvoid %s%s(int NumLinea)\nstruct Espec-Archivo RegArchivo;int

NumLlavesAux = 1 ;

NumLlavesAux = O;

TamPag,Longitud,LongBuffer;\n",NomFuncion, &NomArchivo[l]);

fprintf(Expansion," Longitud = sizeof(struci. -%s);\n",&-TablaAux[l]); fprintf(Expansion," TamPag = CalculaTamPag(Longitud);\n"); fprintf(Expansion," Llena_Espec_Arch(&Rc~gArchivo,Longitud,TamPag,~od,%d,O);\n",

Escribe-LlavesCTablaAux); LongBuffer = 16 + 16 NumLlaves; FormateaCad(NomArch,"%s",&NomArchivo[l],E~ension); fprintf(Expansion," LongBuffer = %d;\n",LongBuffer); fprintf(Expansion," STATUS = BTRV(CREATE,BLOQUEGLOB,(char *)

fprintf(Expansion," if CSTATUS != O) ErrorBtrieveCSTATUS,NumLinea);\n"); fprintf(Expansion,"\n\n\n");

NumLlavesAux,ArchBandera,Prealoc);

&RegArchivo,&LongBu~fer,\"%s\",%d);\n",NornArch,Verificar);

UAM 61

void EscribeOPEN(int NumLinea,char *Extension,char *-TablaAux,char *NomArchivo) char NomFuncion[30];

if ((EstaDefinidaCTablaAux)) != NULL)

FormaLlamada('"OPEN_","",NomArchivo,NumLinea); FormaNombreFuncion("_OPEN_",NumLinea,NomFuncion); fprintf(Expansion,"\nvoid %s%s(int Numl-inea)\n(",NomFuncion,&NomArchivo[l]); fprintf(Expansion,"struct -%S Tab1aAux;int Ap,Longitud,-STATUS;\n",&-TablaAux[l]); fprintf(Expansion," Ap = AltaEnListaB~'~~~s\",NumLinea);\n",&NomArchivo[l]); fprintf(Expansion," if (Ap >= O)\n \n"); fprintf(Expansion," Longitud = sizeof(TablaAux);\n"); fprintf(Expansion," STATUS=BTRV(OPEN,ListaBuf[Ap].BUFFER,

fprintf(Expansion," if (-STATUS != O) ErrorBtrieveCSTATUS,NumLinea);\n"); fprintf(Expansion," \n"); fprintf(Expansion,"\n\n\n");

(char *) &TablaA~x,&Longitud,\"%s%s\",l);\n",&NomArchivo[l],Extension);

1 else Error(N0MTABLA);

1

void EscribeCLOSE(int NumLinea,char *NomArchivo) char NomFuncion[SO]; FormaLlamada("_CLOSE_","",NomArchivo,NumLinea); FormaNombreFuncion("_CLOSE_",NumLin~ea,NomFuncion); fprintf(Expansion,"\nvoid %s%s(int NumLincta)\n(",NomFuncion,&NomArchivo[l]); fprintf(Expansion,"int Ap,-STATUS,Longitutl;char Datos,BufLlave;\n"); fprintf(Expansion," Ap = ObtenBuffer(\"_%s\",NumLinea);\n",&NomArchivo[l]); fprintf(Expansion,

fprintf(Exiansion," if (-STATUS != O) ErrorBtrieveCSTATUS,NumLinea);\n"); fprintf(Expansion," BajaEnListaB~'~%s\",Ap,NumLinea);\n",&NomArchivo[l]); fprintf(Expansion,"\n\n\n");

" STATUS=BTRV(CLOSE,ListaBuf[Ap].BUFFER,&Datos,&Longitud,&BufLlave,l);\n");

1

UAM 62

void EscribeCLOSE-ALL(int NumLinea) char NomFuncion[30];

FormaLlamada('"CLOSEPLL_",""," ",NumL.inea); FormaNombreFuncion("_CLOSE_ALL~",NurnLinea,NomFuncion); fprintf(Expansion,"\nvoid %s(int NumLinea)\n(",NomFuncion); fprintf(Expansion,"int Ap,-STATUS,Longitud;char Datos,BufLlave;\n"); fprintf(Expansion," for (Ap=O; Ap e MAXBUFFERS-I;++Ap)\n"); fprintf(Expansion," \n"); fprintf(Expansion," if (strcmp(ListaBuf[Ap:l.Tabla,\"\") != O)\n"); fprintf(Expansion," \n"); fprintf(Expansion,

fprintf(Ex$ansion," if CSTATUS != O) ErrorBtrieveCSTATUS,NumLinea);\n"); fprintf(Expansion," BajaEnListaB(ListaE~uf[Ap].Tabla,Ap,NumLinea);\n"); fprintf(Expansion," \n"); fprintf(Expansion," \n"); fprintf(Expansion,"\n\n\n");

I, STATUS=BTRV(CLOSE,ListaBuf~~Ap].BUFFER,&Datos,&Longitud,&BufLlave,l);\n");

1

void EscribelNSERT(int NumLinea,char *-TablaAux,char *NomArchivo) char Campo1 [6O],NomFuncion[30]; FormaLlamada("_lNSERT~",&Variable[l],N~omArchivo,NumLinea); ArmaCampoN~TablaAux,&Variable[l],1 ,Cod-flecha,Campol); ForrnaNornbreFuncion("_INSERT~",NumLir~ea,NomFuncion); fprintf(Expansion,"\nvoid %s%s(struct -%S "%s,

fprintf(Expansion,"int Longitud,-STATUS,A.p;\n"); fprintf(Expansion," Longitud = sizeof(struct -%s);\n",&-TablaAux[l]); fprintf(Expansion," Ap = ObtenBuffer(\"_%s\",NumLinea);\n",&NomArchivo[l]); fprintf(Expansion," STATUS=BTRV(INSERT,ListaBuf[Ap].BUFFER,(char *)

fprintf(Expansion," if (-STATUS != O) ErrorBtrieveCSTATUS,NumLinea);\n"); fprintf(Expansion,"\n\n\n"); fflush(Expansion);

int NumLinea)\n",NomFuncion,&NomArchivo[l],&~TablaAux[l],&Variable[l]);

%s,&Longitud,%s,O);\~,&Variable[l],Campol);

1

void FinalizalNSERT(void) LiberaCadUabla); LiberaCad(Variab1e); LiberaCad(CadWhere);

1

void lnsertaEnListaCursor(char *NombreCursor,char *NombreTabla) int Ap=O;

++Ap;

Error(CURS0RDUPL);

while ( (strcmp(CursofiAp][O],NombreCursor) != O) && (strcmp(Cursor[Ap][O],"") != O) )

if ((strcmp(Cursor[Ap][O],NombreCursor) == I)))

else Cursor[Ap][O] = RegresaApCad(Nombre(2ursor); CursofiAp][l] = RegresaApCad(Nombre1rabla);

1 1

/*No puede haber dos cursores declarados cor1 el mismo nombre, aqui se revisa y se inserta en caso de no encontrarlo.*/

void EscribeDECLARE(int NumLinea,char *-TablaAux) char NombreForeach[40],LIamadaCREATE[40],LlamadaOPEN[4O],CadAux[3O],

LlamadalNSERT[40],LIamadaCLOSE[40],NombreTabla[30],0peracion[20], Siguiente[20],CampoCicIo[60];

FormateaCad(CadAux,"_V_O/os",&-TablaAux[l]); Variable = RegresaApCad(CadAux); ObtenCadOperacion(Operacion,Siguiente); EscribeCREATE(NumLinea,".cur",0,JablaE~ux,Ident); strcpy(LlamadaCREATE,LlamadaDb); EscribeOPEN(NumLinea,".cuf',-TablaAux,Ident); strcpy(LlamadaOPEN,LlamadaDb); EscribelNSERT(NumLinea,-TablaAux,ldent); strcpy(LlamadalNSERT,LlamadaDb); EscribeCLOSE(NumLinea,Ident); strcpy(LlamadaCLOSE,LlamadaDb); FormateaCad(NombreTabla,"~V~~~s",&~Tal~laAux[l]); ArmaCampoNCTablaAux,NombreTabla,l ,Cod-punto,CampoCiclo); FormaNombreFuncion('I_DECLARE_",Numl_inea,NombreForeach); fprintf(Expansion,"void %s%s(int NumLinea:)\n",NombreForeach,&ldent[l]); fprintf(Expansion,"("); fprintf(Expansion,"int -STATUS,Ap,Longitud;\n"); fprintf(Expansion,"struct -%S %s;\n",&-TablaAux[l],NombreTabla); fprintf(Expansion," %s",LlamadaCREATE); fprintf(Expansion," %s",LlamadaOPEN); fprintf(Expansion," Longitud = sizeof(%s);\n",NombreTabla); fprintf(Expansion," Ap = ObtenBufferO"_%:s\",NumLinea);\n",&~TablaAux[l]); fprintf(Expansion," STATUS=BTRV(%s,ListaBuf[Ap].BUFFER,(char *)

fprintf(Expansion," if CSTATUS != O) ErrorBtrieve(-STATUS,NumLinea);\n"); fprintf(Expansion," while (-STATUS == O)\n"); fprintf(Expansion," \n"); if (WHERE == TRUE)

&%s,&Longitud,%s,O);\n",Operacion,Nombre~abla,CampoCiclo);

fprintf(Expansion," if 'I);

printsm(&Expansion,CadWhere,O); fprintf(Expansion,"\n");

UAM 64

fprintf(Expansion," h"); fprintf(Expansion," %s",LlamadalNSERT); fprintf(Expansion," \n");

else

fprintf(Expansion," STATUS=BTRV(%s,lListaBuf[Ap].BUFFER,(char *)

fprintf(Expansion," W); fprintf(Expansion," %s",LlamadaCLOSE); fprintf(Expansion,"\n\nh"); lnsertaEnListaCursor(Ident,-TablaAux); FormaLlamada('"DECLAARE~'~,*"~,ldent,Numl~inea);

fprintf(Expansion," %s",LlamadalNSERT);

&%s,&Longitud,%s,O);\n"Siguiente,NombreTabla,CampoCiclo);

1

void IniciaDECLARE(void)

1 DECLARE = TRUE;

void FinalizaDECLARE(void)

LiberaCad(Tab1a); LiberaCadWariable); LiberaCad(CadWhere); LiberaCad(1dent); VaciarListaCod(lNT0); VaciarListaCod(C0LUMNAS); LiberaCad(0rden); LiberaCad(ArchTemp0); DECLARE = FALSE; WHERE = FALSE; Secc-INTO = FALSE; LineaActual = -1 ;

1

void IniciaFOREACH(void)

LiberaCadWariable); Variable = NULL;

1

UAM 65

void ObtenTablaCursor(char *NombreCursor,clhar *Tablacursor) int Ap=O;

++Ap;

strcpy(TablaCursor,Cursor[Ap][l]);

Error(NOEXISTECURS0R);

while ( (strcmp(Cursor[Ap][O],NombreCursor) != O) && (Ap c MAXCURSOR))

if (strcmp(Cursor[Ap][O],NombreCursor) == O)

else

1

char *ConstruyeFOREACH(int NumLinea,char *NombreCursor) char *InicioForeach,LineaComando[l50],LlamadaOpen[40],Campol[40],TablaCursor[40];

ObtenTablaCursor(NombreCursor,TablaCursor); EscribeOPEN(NumLinea,".cur",TablaCursor,NombreCursor); strcpy(LlamadaOpen,LlamadaDb); ArmaCampoN(TablaCursor,Variable,l ,Cod-punto,Campol); InicioForeach=RegresaApCad("\nint -STATUS,Ap,Longitud;\n "); InicioForeach=UneCads(lnicioForeach,Llam~~daOpen,l); FormateaCad(LineaComando," Ap =

ObtenBufferO"_%s\",%d);\n",&NombreCursor[l],NumLinea); InicioForeach=UneCads(lnicioForeach,LineaComando,l); FormateaCad(LineaComando," Longitud = .sizeof(struct -%s);\n",&TablaCursor[l]); InicioForeach=UneCads(lnicioForeach,LineaComando,l); FormateaCad(LineaComando," STATUS=BTRV(STEP-FIRST,ListaBuf[Ap].BUFFER,(char

InicioForeach=UneCads(lnicioForeach,LineaComando,l); FormateaCad(LineaComando," if (-STATUS != O)

strcat(LineaComando," while CSTATUS ==: O)\n \n"); InicioForeach=UneCads(lnicioForeach,LineaComando,l); return(1nicioForeach);

*) &%s,&Longitud,%s,O);\n",&Variable[l],Campol);

ErrorBtrieveCSTATUS,%d);\n",NumLinea);

1

char *TerminaFOREACH(char *NombreCursor,char *VariableAux,char *InicFOREACH,char *CuerpoFOREACH) char *Result;char LineaComando[l50],Campol[50],TablaCursor[50];

ObtenTablaCursor(NombreCursor,TablaCursor); ArmaCampoN(TablaCursor,VariableAux,l ,Cod-punto,Campol); FormateaCad(LineaComando," STATUS=BTRV(STEP-NEXT,ListaBuf[Ap].BUFFER,(char

Result = UneCads(lnicFOREACH,CuerpoFOREACH,3); Result = UneCads(Result,LineaComando,l); return(Resu1t);

*) &%s,&Longitud,%s,O);\n \n\n\n"~&VariableAux[l],Campol);

1

66

void InicialNPUT(void)

NumCampos = O; Limpiar = RegresaApCadr if (Limpiar == TRUE)\n y); CadLlenaVars = RegresaApCadr if (Result =:= O)\n r); DeclDatos = RegresaApCadrchar ");

1

struct CamposFl *RegresalnfoCampo(char *N'ombreTabla,char *Nombrecampo) struct CamposFl *NodoAux;

NodoAux = Listacampos; while ((NodoAux != NULL) && (( strcmp(NodoAux->NombreTabla,NombreTabla) != O) 11

(strcmp(NodoAux->NombreCampo,NombreCampo) != O)) ) NodoAux = NodoAux -> Liga;

if (( strcmp(NodoAux->NombreTabla,NombreTabla) == O) && (strcmp(NodoAux- >NombreCampo,NombreCampo) == O))

return(NodoAux);

return(NULL); else

1

void RegresaDatosCampo(char *NombreTablal,char *NombreCampo,int *Longitud,int *TipoDato) struct CamposFl *NodoAux;

if ((NodoAux = RegresalnfoCampo(NombreTabla,NombreCampo)) != NULL)

if ( (ripODat0 = NodoAux -> TipoDato) != STRING)

switch(*TipoDato)

case INTEGER : *Longitud = 5; case FLOAT : *Longitud = 9; case DATE : *Longitud = 9;

1 1

else

*Longitud = NodoAux -> Longitud; *TipoDato = NodoAux -> TipoDato;

1 1

else Error(NOMCAMP0);

1

UAM 67

void ProcesaAtributos(char *AuxLimpiar,char "CadVars,char *Cadlnicializar,int *Longitud,int *TipoDato,int *Color) (struct Lista-Ids *Aux;int Ap,Result;char CampoAux[50]; ObtenListaTrabajo(ATRlBUTOS,&Aux); while (Aux != NULL)

Ap = O; while ((Result = strcmp(Aux -> Ident,ValorAtributos[Ap].Atributo)) != O && (Ap < 16) ) ++Ap;

if (Result == O) *Color= ValorAtributos[Ap].ValorAttrib;

else Error(ATRIBUT0DESC);

Aux = Aux -> Liga; 1

FormateaCad(CarnpoAux,"@\"%s\"",&CampoCap[I]); RegresaDatosCampoCTabla,CampoAux,Longitud,TipoDato); if ((*TipoDato != FLOAT) && (*TipoDato != INTEGER))

FormateaCad(Cadlnicializar," strcpy(Dato%d,\"\");\n",NumCampos); FormateaCad(CadVars,

strcpy(%s.%s,Dato%d);~.n",&Variable[l],&CampoCap[l],NumCampos); 1

else switch(7ipoDato) case FLOAT : FormateaCad(Cadlnicializar,"ltoa2(Dato%d,%s.%s,l O);\n",

NumCampos,&Variable['I],&CampoCap[l]); FormateaCad(CadVars,"')/os.%s = atof(Dato%d);\n",&Variable[l],&CampoCap[l],NumCampos);;break;

case INTEGER : FormateaCad(Cadlnicializar,"itoa(%s.%s,Dato%d,l O);\n", &Variable[l],&CampoCaap[l],NumCampos); FormateaCad(CadVars,"%s.%s = atoi(Dato%d);\n",&Varia~ble[l],&CampoCap[l],NumCampos);;break;

1 if (*TipoDato != STRINGDATE)

else FormateaCad(AuxLimpiar,"\n strcpy(Dato%d,\"\");",NumCampos);

FormateaCad(AuxLimpiar,"\n strcpy(Dato%d,\" \\ \\ \");",NumCampos); 1

char *FormaLlamadalNPUT(char *Posicion,char *Titulo) char LineaComando[200],*Result,CadLlenaVarsAux[l OO],Auxlnicializar[l OO],AuxLimpiar[I 001;

ProcesaAtributos(AuxLimpiar,CadLlenaVars~~ux,Auxlnicializar,&Longitud,&TipoDato,&Color); if (NumCampos == 1)

int Color,Longitud,TipoDato;

FormateaCad(LineaComando," Dato1 [%ld]",Longitud); DeclDatos = UneCads(DeclDatos,LineaC:omando,l); strcpy(LineaComando,"\n -Ambienta-GET(Campol ,Dato1 ,&lnicX,&FinX,&PosY);\n"); LlamadaAmbienta = RegresaApCad(LineaComando);

1 else

UAM 68

FormateaCad(LineaComando," ,Dato%d[%d]",NumCampos,Longitud); DeclDatos = UneCads(DeclDatos,LineaComando,l); FormateaCad(LineaComando,"

LlamadaAmbienta = UneCads(LlamadaAmbienta,LineaComando,l); - Ambienta~GET(Campo%d,Dato%d,&lnicX,&FinX,&Pos~;\n",NumCampos,NumCampos);

1

Inicializar = UneCads(lnicializar,Auxlnicializar,l); QuitaMarcas(Posicion); QuitaMarcas(Titu1o); FormateaCad(LineaComando,"\n

- LlenaDatosCampo(&Campo%d,%s,%d,%d,0/os,%d);",NumCampos,Posicion,TipoDato,Color,Tit ulo,Longitud);

Result = RegresaApCad(LineaComando); /*LlenaVars*/ CadLlenaVars = UneCads(CadLlenaVars,CadLlenaVarsAux,l);

Limpiar = UneCads(Limpiar,AuxLimpiar,l); return(Resu1t);

1

void SalidaCodigo(char *ListaLineasCaptura,clnar *DeclCampos,char *LlamadaFuncion) char LineaComando[250];

QuitaMarcas(Dec1Campos); LlamadaDb = DeclCampos; LlamadaDb = UneCads(LlamadaDb,";",l); LlamadaDb = UneCads(LlamadaDb,DeclDatos,3); LlamadaDb = UneCads(LlamadaDb,";\n " , l ) ; LlamadaDb = UneCads(LlamadaDb,lnicializar,3); LlamadaDb = UneCads(LlamadaDb,ListaLineasCaptura,3); FormateaCad(LineaComando,"h Result = '%s\n",LlamadaFuncion); LlamadaDb = UneCads(LlamadaDb,LineaCc~mando,l); LlamadaDb = UneCads(LlamadaDb,CadLlenaVars,3); strcpy(LineaComando,"\n \n\n\n"); LlamadaDb = UneCads(LlamadaDb,LineaCa~mando,l);

1

void SalidaExpansion(char *LlamadaPresenta,char *Casos,char *DeclFuncion,char *DeclPresenta)

QuitaMarcas(L1amadaPresenta); QuitaMarcas(Casos); QuitaMarcas(Limpiar); QuitaMarcas(Dec1Funcion); QuitaMarcas(Dec1Presenta); QuitaMarcas(L1amadaAmbienta);

fprintf(Expansion,"%s\n",DeclPresenta); fprintf(Expansion,"int InicX,FinX,PosY;\n"); fprintf(Expansion,"%s\n",LlamadaAmbienta); fprintf(Expansion,"\n\n\n"); fprintf(Expansion,"%s\n",DeclFuncion);

UAM 69

fprintf(Expansion,"int CampoAnt,CampoSig,Salir,TipoSalida;struct text-info VideoActual;\n"); fprintf(Expansion," gettextinfo(&VideoActual);\n CampoSig = 1 ;\n Salir = FALSE;\n");

fprintf(Expansion,"%s",Limpiar); fprintf(Expansion,"\n \n%s",LlamadaPresenta); fprintf(Expansion,"\n do r); fprintf(Expansion,"\n CampoAnt = CarnpoSig;"); fprintf(Expansion," \n switch(CampoSig)"); fprintf(Expansion,"\n ("1 ; fprintf(Expansion,"\n%s",Casos); fprintf(Expansion,"\n \n") ; fprintf(Expansion," CorrigeSig(NumCampos,&CampoSig);\n"); fprintf(Expansion," - PosibleSalida(CampoAnt,NumCampos,TipoSalida,&Salir);\n"); fprintf(Expansion," textattr(VideoActuaI.attribute);\n"); fprintf(Expansion," while ( (Salir == FALSE) && (TipoSalida != -ESCAPEJ );\no'); fprintf(Expansion," if (TipoSalida == -ESC:APEJ\n"); fprintf(Expansion," return(TipoSalida);\n"'); fprintf(Expansion," elseh"); fprintf(Expansion," retum(O);\n"); fprintf(Expansion,"\nh\n");

1

void EscribelNPUT(int NumLinea,char *ListaLineasCaptura) char *DeclCampos,*LlamadaFuncion,*DeclFulicion,*LlamadaPresenta, *DeclPresenta,*Casos,LineaComando[2SO];int Ap; DeclCampos = RegresaApCad("\nint Resu1t;RegGet Campol"); FormateaCad(LineaComando,"int -CapturaC:onjunto-%d(RegGet *Campol,

DeclFuncion = RegresaApCad(LineaComanc1o); FormateaCad(LineaComando,"_CapturaConjunto_%d(&Campol ,Datol",NumLinea); LlamadaFuncion = RegresaApCad(LineaCon1ando); FormateaCad(LineaComando," -Presentacampos-%d(Campol ,Datol",NumLinea); Llamadapresenta = RegresaApCad(LineaComando); FormateaCad(LineaComando,"void -Presentacampos-%d(RegGet *Campol,

char *Datol",NumLinea); DeclPresenta = RegresaApCad(LineaComan1do); Casos = RegresaApCad("\n case 1 :

for (Ap=Z;Ap <= NumCampos;++Ap)

char *Datol",NumLinea);

CapturaCadena(Campo1 ,&CampoSig,Datol ,&TipoSalida);break;");

FormateaCad(LineaComando,",Campo%d",Ap); DeclCampos = UneCads(DeclCampos,LineaComando,l); FormateaCad(LineaComando,",RegGet *Campo%d,char *Dato%d",Ap,Ap); DeclFuncion = UneCads(DeclFuncion,LineeComando,l); FormateaCad(LineaComando,",&Campo%cj,Dato%d",Ap,Ap); LlamadaFuncion = UneCads(LlamadaFuncion,LineaComando,l); FormateaCad(LineaComando,",RegGet *Campo%d,char *Dato%d",Ap,Ap); DeclPresenta = UneCads(DeclPresenta,LineaComando,l); FormateaCad(LineaComando,",Campo%d,l3ato%d",Ap,Ap); Llamadapresenta = UneCads(LlamadaPresenta,LineaComando,l);

FormateaCad(LineaComando,"\n case %d : CapturaCadena(Campo%d,&CampoSig,Dato%d,&TipoSalida);break;",Ap,Ap,Ap);

UAM 70

Casos = UneCads(Casos,LineaComando,'l); 1 FormateaCad(LineaComando,",int NumCarnlpos,int Limpiar)\n"); DeclFuncion = UneCads(DeclFuncion,LineaComando,l); FormateaCad(LineaComando,",%d,FALSE);\n",NumCampos); LlamadaFuncion = UneCads(LlamadaFuncion,LineaComando,l); DeclPresenta = UneCads(DecIPresenta,")\n",l); Llamadapresenta = UneCads(LlamadaPresenta,");\n",l);

SalidaCodigo(ListaLineasCaptura,DeclCamF~os,LlamadaFuncion); SalidaExpansion(LlamadaPresenta,Casos,DeclFuncion,DeclPresenta);

LiberaCad(ListaLineasCaptura); LiberaCad(Dec1Campos); LiberaCad(Dec1Funcion); LiberaCad(ListaLineasCaptura); LiberaCad(Dec1Datos); LiberaCad(lnicializar); LiberaCad(CadL1enaVars);

void FinalizalNPUT(void)

LiberaCadvariable); LiberaCad(Tab1a);

1

/*Indica que funcion se esta realizando.*/ void Accion(int Codigo)

TipoAccion=Codigo; switch (TipoAccion)

case Cod-SELECT : IniciaSelecto; break; case Cod-TABLE : 1niciaCapturaTABLEO;break; case Cod-UPDATE : IniciaUpdate0;break; case Cod-DECLARE: 1niciaDECLAREO;break; case Cod-FOREACH: IniciaFOREACH0;break; case Cod-INPUT : InicialNPUT0;break; case Fin-SELECT : FinalizaSelectO; break; case Fin-DELETE : FinalizaDELETEO; break; case Fin-UPDATE : FinalizaUpdateO; break; case Fin-DECLARE: FinalizaDECLARE0;break; case Fin-INSERT : FinalizalNSERT0;break; case Fin-INPUT : FinalizalNPUT0;break;

1; 1

UAM 71

............................................................................................................................................. ............................................................................................................................................. Archivo : define.c .............................................................................................................................................. ..............................................................................................................................................

/*Semantico*l #define COLUMNAS #define INTO #define ASIGNACION #define ATRIBUTOS #define Fin-SELECT #define Fin-DELETE #define Fin-UPDATE #define Fin-FOREACH #define Fin-DECLARE #define Fin-INSERT #define Fin-INPUT #define TRUE #define FALSE

/*Errores*/ #define MEMORIA #define NUMCAMPOS #define NOMTABLA #define CURSORDUPL #define NUMCAMPO

1 2 3

4 -Cod-SELECT -Cod-DELETE -COd-UPDATE -Cod-FOREACH -Cod-DECLARE -Cod-INSERT -COd-lNPUT

1 O

O 1 2 3 4

#define NOEXISTECURSOR 5 #define ATRIBUTODESC 6 #define NOMCAMPO 7 /*Interface *I

#define NO #define fecha #define cadena #define booleano #define archivo #define UNIQUE #define DUPS #define YES

-1 1 2 3 4 5

6 7

char *Cursor[MAXCURSOR][3];

/*Estructuras *I

struct Lista-Ids char *Ident; struct Lista-Ids *Liga;

1; UAM 72

struct DescrTabla char *Nombrecampo; int TipoDato,Longitud,Indic.e,Nulos;

1;

struct RegldNum char *Ident; int NumElems;

struct RegldNum *Liga; 1;

struct CamposFl char *NombreTabla,*NombreCampo; int TipoDato,Longitud,Tipolndice,TipoValor;

struct CamposFl *Liga; 1;

struct RegAtributos char *Atributo; int ValorAttrib;

1;

static struct RegAtributos ValorAtributos[] = ("@BLACK,O, ("@BLUE",l, r@GREEN",2, ("@CYAN",3, ("@RED",4, ("@MAGENTA",S, "@BROWN",G, "@LIGHTGRAY",7, ("@DARKGRAY",8, ("@LIGHTBLUE",S, "@LIGHTGREEN", 1 O, ("@LIGHTCYAN",l l , ("@LIGHTRED",12, ("@LIGHTMAGENTA,13, ("@YELLOW,14, ("@WHITE",lS 1;

A continuacibn se presentan los archivos que se incluyen al expander el código fuente de un archivo , en este caso de pr0gm.c . En la siguiente figura se muestran los archivos que se incluyen en el codigo expandido.

UAM 73

Fig. 2 Inclusion de archivos del codigo expandido.

//' \\

/* ............................................................................................................................................. ............................................................................................................................................. Archivo : turcbtw.c

*/ /* Borland's Turbo C Version 2 interface to the */ /* Btrieve Record Manager, version 4, 5, 5.1 */ I* */

............................................................................................................................................. .............................................................................................................................................

#include <dos.h> #define BTR-ERR 20 /* record manager not started */ #define BTR-INT Ox7B /* Btrieve interrupt vector */ #define BTR2-INT Ox2F /* multi-user interrupt vector */ #define BTR-VECTOR BTR-INT * 4 /* offset for interrupt */ #define BTR-OFFSET 0x33 /* Btrieve offset within segment */ #define VARIABLE-ID 0x6176 /* id for variable length records - 'va' */ #define -2FCODE OxABOO /* function code for int 2F to btrieve */

/* For Compact, Large, and Huge memory models */ /* LMODEL means 32-bit pointers in use */

#if definedLCOMPACTJ 11 definedLLARGEJ 11 definedLHUGEJ #define LMODEL 1 #endif

/* Procld is used for communicating with the Multi Tasking Version of *I /* Btrieve. It contains the process id returned from BMulti and should */ /* not be changed once it has been set. */

UAM 74

/* */

static unsigned Procld = O; /* initialize to no process id */ static char MULTI = O; /* flag set to true if MultiUser */ static char VSet = O; I* flag set to true if checked version */

int BTRV (int OP,char *POS-BLK, char *DATA-BUF,int *DATA-LEN,char *KEY-BUF, int KEY-NUM) /* int OP;

char POS-BLKU; char DATA-BUF[]; int *DATA-LEN; char KEY-BUFO; int KEY-NUM; */

c union REGS b-regs; /* define registers */

struct SREGS b-sregs; /* define segment registers */

struct BTRIEVE-PARMS /* structure passed to Btrieve Record Manager */

char *BUF-OFFSET; /* callers data buffer offset */

int BUF-SEG; /* callers data buffer segment */

int BUF-LEN; /* length of data buffer */ char *CUR-OFFSET; /* user position block offset */

int CUR-SEG; /* user position block; segment */

char *FCB-OFFSET; /* offset of disk FCB */

int FCB-SEG; /* segment of disk FCB */

int FUNCTION; /* requested function */ char *KEY-OFFSET; /* offset of user's key buffer */

int KEY-SEG; /* segment of user's key buffer */

char KEY-LENGTH; /* length of user's key buffer */ char KEY-NUMBER; /* key of reference for request */ int *STAT-OFFSET; /* offset of :status word */

int STAT-SEG; /* segment of status word */

int XFACE-ID; /* language identifier */

#ifndef LMODEL

#endif

#ifndef LMODEL

#endif

#ifndef LMODEL

#endif

#ifndef LMODEL

#endif

#ifndef LMODEL

#endif

XDATA;

int STAT = O; I* status of Btrieve call */

/* */ /* Check to see that the Btrieve Record Manager has been started. */ /* */

if (!VSet) /* if we don't know version of E3trieve yet */

UAM 75

VSet = 1; b-regs.x.ax = 0x3000; /* check dos version */ int86x (0x21, &b-regs, &b-regs, &b-sregs); if ((b-regs.x.ax & OxOOFF) >= 3) I* if DOS version 3 or later */

b-regs.x.ax = 2FCODE; int86x (BTR2¡íNT, &b-regs, &b-regs, &b-s,regs); MULTI = ((b-regs.x.ax & OxFF) == 'M');/* if al is M, bmulti is loaded */ 1

1

if (!MULTI) /* if bmulti not loaded */ b-regs.x.ax = 0x3500 + BTR-INT; int86x (0x21, &b-regs, &b-regs, &b-sregs); if (b-regs.x.bx != BTR-OFFSET)

1 return (BTR-ERR);

/* Read segment registers and initialize segment part of addresses to */ /* user's data segment. */ /* */

segread (ab-sregs); #ifndef LMODEL XDATA.BUF-SEG = XDATA.CUR-SEG = XDATA.FCB-SEG =

#endif XDATA.KEY-SEG = XDATA.STAT-SEG = trsregs.ss;

/* */ /* Move user parameters to XDATA, the block; where Btrieve expects them.*/ /* *I

XDATA.FUNCTION = OP; XDATA.STAT-OFFSET = &STAT; XDATA.FCB-OFFSET = POS-BLK; XDATA.CUR-OFFSET = POS-BLK + 38; XDATA.BUF-OFFSET = DATA-BUF; XDATA.BUF-LEN = *DATA-LEN; XDATA.KEY-OFFSET = KEY-BUF; XDATA.KEY-LENGTH = 255; /* use max since we don't know */ XDATA.KEY-NUMBER = KEY-NUM; XDATA.XFACE-ID = VARIABLE-ID;

/* */ /* Make call to the Btrieve Record Manager. */ /* *I

b-regs.x.dx = (int) &XDATA; /* parameter blo'ck is expected to be in DX */ b-sregs.ds = b-sregsss; if (!MULTI)

int86x (BTR-INT, &b-regs, &b-regs, &b-sregs); else /* call bmulti *I

UAM 76

while (1) b-regs.x.ax = 1 ; /* assume no proc id obtained yet */ if ((b-regs.x.bx = Procld) != O) /* if we have a proc id */ b-regs.x.ax = 2; /* tell bmulti that */

b-regs.x.ax += -2FCODE; int86x (BTR2-INT, &b-regs, &b-regs, &b-sregs); if ((b-regs.x.ax & OxOOFF) == O) break; /* if call was processed */

b-regs.x.ax = 0x0200; /* if multilink advanced is loaded, it will */ int86x ( O X ~ F , &b-regs, &b-regs, &b-sregs); /* it will switch processes */

/* by bmulti, leave loop */

1 if (Procld == O) Procld = b-regs.x.bx; 1

/* DATA-LEN = XDATA.BUF-LEN; */ return (STAT); /* return 1

status */

UAM 77

/*

Archivo : bib1io.c

*/ #include "btrv.c"

............................................................................................................................................. .............................................................................................................................................

............................................................................................................................................. .............................................................................................................................................

##define NOABIERTA -1 Mefine VARIOSREGISTROS -2 ##define DEMASIADASTABLAS -3 ##define TABLABIERTA -4

Mefine -ALTA-BUFFER 1 ##define -BAJA-BUFFER 2

/*MAXBUFFERS puede cambiarse a otro include al termino del analisis.*/ ##define MAXBUFFERS 10

int -STATUS; char BLOQUEGLOB[l28];

struct descriptor

char BUFFER[128]; char Tabla[l5];

1;

struct descriptor ListaBuf[MAXBUFFERS];

void ErrorT(int TipoError,int NumLinea) char ErrorM[80];

switch(TipoError)

case NOABIERTA : strcpy(ErrorM,"LA TABLA NO ESTA AB1ERTA");break; case VARIOSREGISTROS : strcpy(ErrorM,"LA CONSULTA REGRESO MAS DE UN

case DEMASIADASTABLAS: strcpy(Errol","DEMASIADAS TABLAS AB1ERTAS");break; case TABLABIERTA : strcpy(ErrorM,"LA TABLA YA FUE AB1ERTA");break;

REGISTR0");break;

1 printf("\n%s , ERROR EN LINEA %d \n",ErrorM,NumLinea); exit(TipoError);

1

void Llena-Espec-Llave(struct Especific-Llave *RegLlave,int PosLlave,int LongLlave,int BanderaLlave,char TipoLlave)

RegLlave -> Pos-Llave = PosLlave; RegLlave -> Long-Llave = LongLlave; RegLlave -> Bandera-Llave = BanderaLlave; RegLlave -> Tipo-Llave = TipoLlave; strcpy(RegL1ave -> NoUsado , "'I);

strcpy(RegL1ave -> Reservado, ""); 1

78

void Llena-Espec-Arch(struct Espec-Archivo *Reg-Archivo,int Long,int TarnPag, int Numlndices,int ArchBandera,int Prealoc)

Reg-Archivo -> Long-Reg = Long; Reg-Archivo -> Tam-Pag = TarnPag; Reg-Archivo -> Num-Indices = Numlndices; Reg-Archivo -> Arch-Bandera = ArchBandera; Reg-Archivo -> Prealoc = Prealoc; strcpy(Reg-Archivo -> No-Usado , ""); strcpy(Reg-Archivo -> Reservado , I"');

1

int CalcSobrante(int TamRegjnt NurnRegs) int Sobran;

Sobran = 512 NumRegs - TamReg*(512*NurnRegs/TamReg) - 6; if (Sobran e O)

else return(512*NumRegs);

return(Sobran); 1

int CalculaTamPag(int TarnReg) int Ap,Multiplo,Sobrante,Tempo;

Multiplo = 1; Sobrante = CalcSobrante(TamReg,Multiplo); for (Ap = 2; Ap e 8 ; ++Ap)

if ( (Tempo = CalcSobrante(TamReg,Ap)) < Sobrante)

Multiple = Ap; Sobrante = Tempo;

1 1 return(512*Multiplo);

1

void LimpiaListaBuf(void) int Ap;

for (Ap=l ;Ap < MAXBUFFERS;++Ap) strcpy(ListaBuf[Ap].Tabla,"");

1

int ObtenBuffer(char *TablaAux,int NurnLinea) int Ap;

Ap = O; while ((strcmp(ListaBuf[Ap].Tabla,TablaAux) != O) && (Ap e MAXBUFFERS))

++Ap; if ( strcrnp(ListaBuf[Ap].Tabla,TablaAux) != O) ErrorT(NOABIERTA,NurnLinea);

UAM 79

return(Ap); 1

int CTRLBuffer(char *TablaAux,int Operacion,int NumBufferjnt NumLinea) int Result,Ap;

Result = -1 ; if (Operacion == -ALTA-BUFFER)

Ap = O; while ((strcmp(L/staBuf[Ap].Tabla,TablaA~~x) != O) && (Ap "BUFFERS))

if ((strcmp(ListaBuf[Ap].Tabla,"") == 0) && (Result == -1))

++Ap; Result = Ap;

1 if ((strcmp(ListaBuf[Ap].Tabla,TablaAux) =:= O)) ErrorT(TABLABIERTA,NumLinea);

1

if (Operacion == -BAJA-BUFFER)

if (strcmp(ListaBuf[NumBuffer].Tabla,TablaAux) != O) ErrorT(NOABIERTA,NumLinea);

strcpy(ListaBuf[NumBuffer].Tabla,""); 1 return(Resu1t);

1

int AltaEnListaB(char NomArch[lfi],int NumLinea) static int Inicio=O;int Ap;

if (Inicio == O)

LimpiaListaBufO; Inicio = 1;

1 Ap = CTRLBuffer(NomArch,-ALTA-BUFFE.R,O,NumLinea); strcpy(ListaBuf[Ap].Tabla,NomArch); return(Ap);

1

void BajaEnListaB(char NomArch[lS],int NumBuffer,int NumLinea)

CTRLBuffer(NomArch,_BAJA_BUFFER,NumBuffer,NumLinea); 1

UAM 80

I*

Archivo : sayget.c

*I

.............................................................................................................................................. ..............................................................................................................................................

.............................................................................................................................................. ..............................................................................................................................................

#include "types.c"

struct RegistroGet int TipoDato,Color,Longitud,PosX,PosY; char Mensaje[50];

1;

typedef struct RegistroGet RegGet;

#define A-CHAR 1 Mefine A-INT 2 #define A-DATE 4 ##define A-REVERSE 8 ##define TRUE 1 ##define FALSE -1

#define -ARRIBA- 72 ##define -ABAJO- 80 Mefine -DER- 77 #define -IZQ- 75 #define -ESCAPE- 27 #define -ENTER- 13 ##define -FLECHA- I O #define -DELETE- 83

struct Simbolos char hor,vert,izqarriba,izqabajo,derarriba,derabajo;

1;

void -Pinta-Horizontal(int PosX,int PosYjnt Cantidad,char Caracter) int Ap;

gotoxy(PosX,PosY); for (Ap=PosX;Ap Cantidad ; ++Ap)

putch(Caracter); 1

void -Pinta-Vertical(int PosX,int PosY,int Cantidad,char Caracter) int Ap;

gotoxy(PosX,PosY); for (Ap=PosY;Ap Cantidad;++Ap)

putch(Caracter); gotoxy(PosX,Ap);

81

void -Pinta-Carac(int PosX,int PosY,char Carac)

gotoxy(PosX,PosY); putch(Carac);

1

void -Marcos(int X1 ,int Y1 ,int X2,int Y2,int TipoMarco,int Color) (struct text-info VideoActua1;char CadAux[l O];

struct Simbolos CaracBox = (IA','3','Ú','~,'¿','U' ,

gettextinfo(&VideoActual); textcolor(Co1or); - Pinta-Carac(X1 ,Y1 ,CaracBox[TipoMarco].izqarriba); - Pinta-Horizontal(Xl+l ,Y1 ,X2,CaracBox[TipoMarco].hor); - Pinta-Carac(X2,Yl ,CaracBox[TipoMarco].derarriba); - Pinta_Vertical(X2,Yl+l ,Y2+1 ,CaracBox[TipoMarco].vert); - Pinta-Vertical(X1 ,Y1+1 ,Y2+1 ,CaracBox[TipoMarco].vert); - Pinta-Carac(X1 ,Y2,CaracBox[TipoMarco] izqabajo); - Pinta-Horizontal(Xl+l ,Y2,X2,CaracBox[TipoMarco].hor); - Pinta~Carac(X2,Y2,CaracBox[TipoMarco] derabajo); textattr(VideoActual.attribute);

(IF 101 l~l , lp,t , , ! ,~x ; 9 ,

1

void -LlenaDatosCampo(RegGet *Campo,int PosX,int PosY,int TipoDato,int Color,char *Mensaje,int Longitud)

(Campo -> TipoDato) = TipoDato; (Campo -> Color) = Color; (Campo -> Longitud) = Longitud; (Campo -> PosX) = PosX; (Campo -> POSY) = PosY; strcpy(Campo -> Mensaje,Mensaje);

1

void pausaro char Pausa;

Pausa = getcharo; Pausa = Pausa;

1

void -EscribeCad(int PosXjnt PosY,char *Cadena)

gotoxy(PosX,PosY); printf("%s",Cadena);

1 /* """""""""""""""""""""""-"""""""""""" *I

void -Ambients-GET(RegGet *Campo,char *Dato,int *InicX,int *FinX,int *POSY) int ColorBarra; gotoxy(Campo->PosX,Campo->POSY); printf("%s",Campo->Mensaje); 'InicX = wherexo; *FinX = *InicX + Campo -> Longitud;

UAM 82

*POSY = Campo -> POSY; ColorBarra = Campo -> Color ; textbackground(Co1orBarra); window(*lnicX,Campo->PosY,*FinX-1 ,Campo->PosY); clrscro; printf("%s",Dato); window(1 ,1,80,25);

1

int EsFlecha(int Tecla2)

if ((Tecla2 == -ARRIBA_) 11 (Tecla2 == -ABAJOJ 11 (Tecla2 == -Iza_) 11 (Tecla2 == -DER_))

else return(TRUE);

return(FALSE); 1

int EsFlechaACampo(int Teclajnt PosX,int InicX,int FinX)

if ((Tecla == ARRIBA_) 11 (Tecla == -ABA,JOJ)

else return(Tec1;);

if ( ( (Tecla == -IZQJ && (PosX == InicX)) 11 ((Tecla == -DER_) && (PosX == FinX)) )

else return(Tec1a);

return(0); 1

void -SiguienteCampo(int Tecla,int *Siguiente)

switch (Tecla)

case -ARRIBA- : --(*Siguiente) ; break; case -ABAJO- : ++(*Siguiente) ; break; case -DER- : ++(*Siguiente) ; break; case -IZQ- : --(*Siguiente) ; break;

1 1

void -DeterminaSalida(int Teclal ,int Tecla2,int Result,int *Salir,int *Siguiente)

if (Result == O)

*Salir = Teclal ; ++(*Siguiente);

1 SiguienteCampo(Tecla2,Siguiente);

1 -

UAM 83

void BackSpace(int InicX,int PosY,char *Dato,int *Longitud,int *Ap) int PosXAux;

if (wherexo - 1 >= InicX)

PosXAux = wherexo - 1; DatorLongitud] = 'bc0'; strcpy(&Dato[*Apl],&Dato[*Ap]);

"Longitud); - EscribeCad(lnicX,PosY,Dato); - EscribeCad(wherexO,PosY," ");

"YAP);

gotoxy(PosXAux,PosY); 1

1

void Delete(int InicX,int PosY,char *Dato,int *Longitud,int *Ap) int PosXAux;

if (*Ap *Longitud)

PosXAux = wherexo ; DatorLongitud] = 'bc0'; strcpy(&Dato[*Ap],&Dato[*Ap+l]); --(*Longitud); - EscribeCad(lnicX,PosY,Dato); - EscribeCad(wherexO,PosY," "); gotoxy(PosXAux,PosY);

1 1

void -Teclalzq(int InicX,int PosY,int *Ap,int *T'ecla2,int Salto)

if (wherexo - Salto >= InicX) gotoxy(wherex0-Salto,PosY); *Ap=Salto; *Tecla2=0;

1 1

void -TeclaDer(int FinX,int PosYjnt *Ap,int *L.ongitud,char *Dato,int Salto)

if (wherexO+Salto <= FinX)

if (*Ap + Salto >= *Longitud)

DatorAp] = I;

*Longitud+=Salto;

gotoxy(wherexO+Salto,PosY); *Ap+=Salto;

1 else

*Longitud+=Salto;

84 UAM

int EsCaracterValido(int TipoCaptura,char Caracter)

if ( (Tipocaptura == A-CHAR) 11 ( ((Tipocaptura == A-INT) 11 (Tipocaptura == A-DATE) ) && (isdigit(Caracter))) )

else return(1);

return(0); 1

void CapturaCadena(RegGet *Campo,int *Siguiente,char *Dato,int 'Salir) int Ap,TipoCaptura,Longitud,InicX,FinX,PosY;char Teclal ;int Tecla2,Result=O; - Ambienta-GET(Campo,Dato,&lnicX,&FinX,&PosY); gotoxy(lnicX,PosY); Longitud = stden(Dat0) + 1 ; Tipocaptura = Campo -> TipoDato; *Salir = Ap = O; do

Tecla2 = O; Teclal = (char) getcho; if (kbhito != O)

Tecla2 = getcho; if (Tecla2 == -1ZQJ

if ( (Tipocaptura == A-DATE) 8.& ((Ap == 3) 11 (Ap == 6)))

else Teclalzq(lnicX,PosY,&Ap,&Tecla2,2);

Teclalzq(lnicX,PosY,&Ap,&Tecla2,1); 1

else if (Tecla2 == -DER_)

-

if ( (Tipocaptura == A-DATE) && ((Ap == 1) ) I (Ap == 4)))

else TeclaDer(FinX,PosY,&Ap,;LLongitud,Dato,2);

- TeclaDer(FinX,PosY,&Ap,&Longitud,Dato,l); 1

if ((Tecla2 == -DELETE_) && ('TipoCaptura != A-DATE)) else

Delete(lnicX,PosY,Dato,&longitud,&Ap); 1

else if ((Teclal != 8) && (Teclal != -ENTE:R_) && (Teclal != -ESCAPE_))

if (EsCaracterValido(TipoCaptura,Teclal))

Dato[Ap] = Teclal ; putch(Tecla1); if (Ap + 1 > Longitud)

++Longitud; if ((Tipocaptura == A-DATE) && ( (Ap == 1) 11 (Ap == 4)) )

UAM 85

Ap += 2; gotoxy(wherexO+l ,Posy);

1 else

++Ap; 1

1

else

if ((Teclal == 8) && (Tipocaptura != A-DATE)) BackSpace(lnicX,PosY,Dato,&L~Dngitud,&Ap;

1 while ( ( (int) Teclal != -ENTER_) &&

((ResuIt=EsFlechaACampo(Tecla2,wherex~,InicX,FinX)) == O) && (Ap + InicX e FinX) && ((int) Teclal != -ESCAPE_) );

if (Result == -DER_)

Dato[Longitud] = 'k0'; --Longitud;

DeterminaSalida(Tecla1 ,Tecla2,Result,Salir,Siguiente); 1 -

void -CorrigeSig(int NumCampos,int *CampoSig)

if (*CampoSig > NumCampos) *CampoSig = 1;

if (*CampoSig < 1) *CampoSig = NumCampos;

void -PosibleSalida(int CampoNjnt NumCampos,int TipoSalida,int *Salir)

if ((CampoN == NumCampos) && (TipoSalitla ==-ENTER_)) *Salir = TRUE;

1

float atof2(char 'CadNum) int Ap=O;float Result=O,Potencia=l ;

while (CadNum[Ap] != NULL)

Result += (long double) ( (Potencia) (float) (CadNum[Ap]-'O') ); Potencia *=1 O; ++Ap;

return(Resu1t); 1

1

UAM 86

#include <stdio.h> #include <string.h> #include <stdlib.h> #include <conio.h> #include <ctype.h>

#define SINTAXFECHA 1 #define MESINVALIDO 2 #define DlAlNVALlDO 3 #define FECHANORESTABLE 4

typedef char DATEBTRV[4];

struct DiasEnMes int DiasPorMes;

1;

UAM 87

APElUDlCE G ACCIONES LEXICAS.

I*

Archivo : LexicoO2.c

*I %p 4000

.............................................................................................................................................. ..............................................................................................................................................

.............................................................................................................................................. ..............................................................................................................................................

Letra [a-zA-ZJ

ALFA (LetralDI[,.@!#$%A&*O]l[ I) S [h"*pl define [Vn] NUMERO DXD)' DECIMAL NUMERO[.]NUMERO EXPONENTE (DECIMAL~NUMERO)[Eel(".e"J"-"J"")NUMERO CADENA [II](ContenidoCad)*["]

Comilla Y Token Letra(LetralD)* ContenidoCad Slflokenl"*"l"/" ldentificador floken DelimBasico (" "l\nl\t) Entre "/" Por "*" InicComentario EntrePor Delim (DelimBasico)+ LINEACONTROL #(define*

D [O-91

CARACTER ~ I I I ~ ~ ~ ~ ) , , ~ ~ ~ ~ I ~ I I I ~ ~ \ " x ~ ~ ~ ~ I I ~ I ~ ~ I I I I I I I \ " ~ ~ A ~ ~ A ) " I I I )

%%

InicComentario RetiraDeEntradaO; Delim printf(""); NUMERO return(Cod-constante-entera); DECIMAL return(Cod-constante-flotante); EXPONENTE retum(Cod-constante-flotante); CADENA return(Cod-constante-de-caracter); CARACTER return(Cod-constante.-de-caracter); LINEACONTROL fprintf(Codigo,"%s\n",yytext); If 1 It return(Cod-admira );

"&" return(Cod-ampersand); "&='@ return(Cod-and-igual);

'I" return(Cod-corchete-abre); "I" return(Cod-corchete-cierra); ">>" return(Cod-corrimiento-der ); ''<<I* return(Cod-corrimiento-izq); 11>=11 return(Cod-der-igual); "! =" return(Cod-diferente-igual); "&&" return(Cod-doble-ampersand ); " I I " return(Cod-doble-or);

"I=" return(Cod-entre-igual);

11 M retum(Cod-coma);

I,. 11 return(Cod-dos-puntos);

UAM 88

11"

I, ,I

IIA=IV

...

Identificador)

Entre %%

Por

return(Cod-flecha); return(Cod-gato); return(Cod-gorro );

return(Cod-comilla); retum(Cod-igual );

return(Cod-igual-igual); retum(Cod-interroga);

return(Cod-izq-igual); return(Cod-llave-abre); retum(Cod-llave-cierra); return(Cod-mas);

return(Cod-mas-igual); return(Cod-mas-mas);

return(Cod-mayor-igual); return(Cod-menor); return(Cod-menor-igual);

return(Cod-menos); return(Cod-menos-igual); return(Cod-menos-menos );

return(Cod-mod-igual); return(Cod-or ); return(Cod-or-igual);

return(Cod-paren-abre); return(Cod-paren-cierra); return(Cod-pesos);

return(Cod-pipe);

return(Cod-mayor);

return(Cod-por-igual); return(Cod-porciento);

return(Cod-punto); return(Cod-punto-coma); return(Cod-tilde); return(Cod-tres-puntos ); return(Cod-xor-igual);

return(Cod-por); return(Regresa-Token(yytext));

return(Cod-entre);

/*Final debe actualizarse si se da de alta o se elimina un token de la lista. */ int Regresa-Token(char *Token) int Inicio,Final,Mitad,Result; static char *PalabraReservada[] = "ALL", "ATTRIBUTE", "BOF", "BOOLEAN", "BOTTOM", "BOX, "By", "CDELETE", "CHAR, "CINSERT", "CLOSE",

UAM 89

"COL", "CONTINUE", "CREATE", "CURSOR", "DATE", "DATEADDNUM", "DATECMP", "DAY", "DECLARE", "DEFINE", "DELETE", "DELETED", "DEVICE", "DOUBLE", "DUPS", "END", "EXFILE", "FILE", "FLOAT", "FOR", "FOREACH", "FOUND", "FROM", "GET", "GETS", "GO", "IN", "INDEX, "INPUT", "INSERT", "INTEGER", "INTO", "LOCATE", "LOWER", "LUPDATE", "MONTH", "NEXT" , "NO", "NONULLS", "NULLS", "NUMERO", "ON", "OPEN", "ORDER, "PICTURE", "PRINT", "REINDEX, "REPLACE", "REPLICATE", "RIGHT", "ROUND", "ROW, "RTRIM", "SAY", "SCREEN", "SEEK,

UAM 90

"SELECT", "SET",

"STUFF", "SUM", "TABLE", "TEMP", "TO", "TOP", "TRIM", "UNIQUE", ''UPDATE'', "UPPER", "VALUES", "WHERE", "WHILE", "WITH", "YEAR", "arroba", "auto", "break", "case", "char", "close", "const", "continue", "default", "define", "do", "double", "elif', "else", "endif', "enum", "error", "extern", "float", "for", "goto", "if', "include", "int", "line", "long", "pragma", "register", "return", "short", "signed",

"static", "struct", "switch", "typedef', "undef", "union",

"SORT",

"sizeof',

- UAM 91

"unsigned", "void", "volatile", "while" 1;

Inicio = O; Final = 126; Mitad = (Inicio + Final) YO 2; if (strcmp(PalabraReserada[lnicio],Token) != O)

while ( Inicio c: Final)

Mitad = (Inicio + Final) / 2; if (strcmp(Token,PalabraReservada[Mitad]) e= O)

else Final = Mitad;

Inicio = Mitad + 1; 1 if (strcmp(Token,PalabraReservada[NIitad]) e= O)

else

if (strcmp(Token,PalabraReservada[Result]) == O)

else

Result = Mitad;

Result = Mitad + 1;

return(Result+307);

return(1dentificador); 1

else return(lnicio+307);

1

int yywrapo

return(1);

1

RetiraDeEntrada(v0id) char Caracjnt Salir=O;

Carac=inputO; if (Carac == '*I)

do

Carac=inputO; if (Carac == I/')

Salir = 1; 1

while (Salir != 1); 1

UAM 92

APENDICE H ACCIONES SEMANTICAS.

%union

1 char 'Cadena;

%token

Cod-admira, Cod-ampersand, Cod-and-igual, Cod-coma, Cod-corchete-abre, Cod-corchete-cierra, Cod-corrimiento-der, Cod-corrimienlo-izq, Cod-der-igual, Cod-diferente-igual, Cod-doble-ampersand, Cod-doble-or, Cod-dosguntos, Cod-entre, Cod-entre-igual, Cod-flecha, CodAato, Codgorro, Cod-comilla, Cod-igual, Cod-igual-igual, Cod-interroga, Cod-izq-igual, Cod-llave-abre, Cod-llave-cierra, Cod-mas, Cod-mas-igual, Cod-mas-mas. Cod-mayor, Cod-rnayor-igual, Cod-menor, Cod-menor-igual, Cod-menos, Cod-menos-igual, Cod-menos-menos, Cod-mod-igual, Cod-or, Cod-or-igual, Codgaren-abre, Cod-paren-cierra, Codgesos, Codgipe, Cod-por, Cod-px-igual, Codgorciento, Cod-punto, Cod-punto-coma, Cod-tilde, Cod-tres-puntos. Cod-xor-igual,

Cod-ALL, Cod-ATTRIBUTE, Cod-BOF, Cod-BOOLEAN, Cod-BOTTOM, Cod-BOX, Cod-BY, Cod-CDELETE, Cod-CHAR, Cod-CINSERT, Cod-CLOSE, Cod-COL, Cod-CONTINUE, Cod-CREATE, Cod-CURSOR, Cod-DATE, Cod-DATEADDNUM. Cod-DATECMP, Cod-DAY, Cod-DECLARE, Cod-DEFINE, Cod-DELETE, Cod-DELETED, Cod-DEVICE, Cod-DOUBLE, Cod-DUPS, Cod-END, Cod-EXFILE,Cod-FILE, Cod-FLOAT, Cod-FOR, Cod-FOREACH, Cod-FOUND, Cod-FROM, Cod-GET, Cod-GETS, Cod-GO, Cod-IN, Cod-INDEX, Cod-INPUT, Cod-INSERT, Cod-INTEGER, Cod-INTO, Cod-LOCATE, Cod-LOWER, Cod-LUPDATE,Cod-MONTH ,Cod-NEXT, Cod-NO, Cod-NONULLS, Cod-NULLS, Cod-NUMERO, Cod-ON, Cod-OPEN, Cod-ORDER, Cod,-PICTURE, Cod-PRINT, Cod-REINDEX, Cod-REPLACE, Cod-REPLICATE, Cod-RIGHT, Cod-ROUND, Cod-ROW, Cod-RTRIM, Cod-SAY, Cod-SCREEN, Cod-SEEK, Cod-SELECT, Cod-SET, Cod-SORT, Cod-STUFF, Cod-SUM. Cod-TABLE, Cod-TEMP, Cod-TO, Cod-TOP, Cod-TRIM, Cod-UNIQUE. Cod-UPDATE, Cod-UPPER, Cod-VALUES, Cod-WHERE, Cod-WHILE, Cod-WITH, Cod-YEAR, Cod-arroba, Cod-auto, Cod-break, Cod-case, Cod-char, C:od-close, Cod-const, Cod-continue, Cod-default, Cod-define, Cod-do, Cod-dOUlJle, Cod-elif, Cod-else, Cod-endif, Cod-enum, Cod-error, Cod-extern, Cod-float, C:od-for, Cod_goto. Cod-if, Cod-include. Cod-int, Cod-line, Cod-long, Cod-pragma, Cod-register, Cod-return, Cod-short, Cod-signed, Cod-sizeof, Cod-static, Cod-struct, Cod-switch, Cod-typedef, Cod-undef, Cod-union, Cod-unsigned, Cod-void, Cod-volatile, Cod-while,

Cod-constante-entera,Cod-constante-flotante, Cod-A,Cod-C,Cod-D,Cod-N,Cod_Nueve, Cod-X,Cod-constante-enumeracion,Cod-numerico, Identificador-Dbase,Identificador_typedef,ldenti~cador, Cod-constante-de-caracter

%type <Cadena> Lista-De-ldentificadores,ldentificador, Lista-De-ldentificadores-O-Todos,Cod-por ,Constante,ExF~resion-Primaria, Expresion-Posfija,Cuerpo-Expr-Posfija ,Expresion-Posfija, Lista-Expresiones-Argumento,Lista-Expr_AUnuario, Expresion-Unuaria,Expresion,Expresion_De-Asignacion,Ex~~resion-Condicional, Operador-De-Asignacion,Expresion-Constante,Expresion-l-ogica-OR, Expresion-Logica-AND,Expresion-OR-Inclusivo,Expresion._OR-Exclusivo, Expresion-AND,Expresion-De-lgualdad,Expresion_RelacionaI, Cuerpo_Expresion-Relacional,Expresion-De-Corrimiento,Cuerpo-Expr_De-Corr, Expresion-Aditiva, Expresion-Multiplicativa,Cuerpo-Expr-M~Jltip,Expresion-Cast, Nombre-De-Tipo,Proposicion,Proposicion-Expresion, Propasicion-Etiquetada , Proposicion-Compuesta , Propsicion-De-Seleccion , Proposicion-De-lteracion , Proposicion-De-Salto , Definicion-De_Funcion,Declaracion-E~erna,Unidad-De-Tr~~duccion, Especificadores-De-Declaracion ,Declarador,Lista-De-Declaraciones-O-Nada, Lista-De-Declaraciones,Declaracion,Lista-Declaradores-lnit,Declarador-lnit, Inicial,Inicializador,Especificador_Categoria-Almacenamiento, Especificador-De-Tip,Calificador-De-Tipo,Es~ci~cador-l~structura-O-Union, Especificadores-De_Declaracion,Lista-Declaraciones-Struct, Cuerpo-Estructura_O-Union,Estructura-O-Union,Declaracion_Struct,

UAM 93

Lista-Calificador-Especifi~dor,Lista-Declaradores_Struct ,Lista-Calif-Espec, Declarador-Struct, Declarador-O_Nada.Expr-Cte,ldent-Er~um,Lista-De-Enumerador, Cuerpo-Enum, Especificador-Enum,Enumerador,lgual-Expr-Cte,ldent-Enum, Lista-De_ldentificadores_4Nada,Apuntador,Declarador-C)irecto, Cuerpo-Declarador-Directo,Expresion-Constante-O-Nad~l,Lista-Tipos-De-Parametro, Apuntador-O-Nada,Lista_Calificadores-De-Tipo-O-Nada, Lista_Calificadores_De-Tipo,Coma-O-Nada,Lista-De-Pafametr~,Puntos-O-Nada, Declaracion_Parametro,Cuerpo-Declaracion-Parametro,Df?clarador-Abstracto, Lista-De_lnicialuadores,Declarador-Abstracto-Directo, Lista-Tipos_De-Parametro_qNada,Declarador-Abstractc~O-Nada, Lista_Proposicion_O-Nada,Lista_De-Proposiciones,Cuerpo_Proposicion-Compuesta, Expresion_O-Nada,Cuerpo_for-Auxiliar,Cuerpo-for,Else-O-Nada,Declarador-Struct, CadAux, Tipo-lndice , Tipo-Valor , Tipo-dato-extendido, Lista-Lineas-Captura , Linea-Captura , Posicion-Cursor,INTO-O-Nada, Tipo-Marco-O-Nada,Coma-Numero

%%

Unidad-De-Inicio : (Encabezado(); Unidad-De-Traduccion

Unidad-De-Traduccion : Declaracion-Externa 1 Unidad-De-Traduccion Declaracion-Externa

Declaracion-Externa : Definicion-De-Funcion ($$=$1 ;printsm(&Codigo,$$,O);LiberaCad($$); I Declaracion ($$=$l;printsm(&Codigo,$$,O);L~beraCad($$); 1 Declaracion-Tabla $$=NULL;

CadAux : ($$=$S;

Definicion-De-Funcion : Especificadores-De-Delaracion ,Jeclarador CadAux ($3=UneCads($l,$2.3); Lista-De-Declaraciones-O-Nada ($3=UneCads($3,$5,3); Proposicion-Compuesta ($$=UneCads($3,$7,3);

($3=UneCads($l,$2,3); Proposicion-Compuesta ($$=UneCads($3,$5,3);

I Declarador Lista-De-Declaraciones_O_Nada CadAux

Declaracion : Especificadores-De-Declaracion Lista-Declaradores-Init Cod-punto-coma CadAux ($4=UneCads($l,$2,3);$$=UneCads($4,";\n",l);

1 Especificadores-De-Declaracion Codgunto.-coma ($$=UneCads($l ,";W,l);

Lista-De-Declaraciones-O-Nada : Lista-De-Declaraciones ($$=$1;) I $$=NULL;

Lista-Declaradores-lnit : Declarador-Init ($$=$1; I Lista-Declaradores-lnit Cod-coma Declarador-lnit ($$=CadcomaCad($l,$3);

Declarador-lnit : Declarador Inicial $$=UneCads($l,$2,3);

Inicial : Cod-igual lnicializador ($$=UneCads("=",$2,2);] I ($$=NULL;

Lista-De-Declaraciones : Declaracion ($$=$1; I Lista-De-Declaraciones Declaracion ($$=UneCads($l,$2,3);)

UAM 94

Especificadores-De-Declaracion : Especificador-Categoria-Almacenamiento Especificadores-De-D'eclaracion $$=UneCads($l,$2,3);

I Especificador-De-Tipo Especificadores-De-Declaracion $$=UneCads($l,$2,3);)

I Calificador-De-Tipo Especificadores-De-Declaracion $$=UneCads($l,$2,3);

I Especificador-Categoria-Almacenamiento $$=$1; I Especificador-De-Tipo $$=$1; I Calificador-De-Tipo $$=$1; I Cod-TABLE ldentificaclor $$=ExpandeTABLE(yy.ext);

Especificador-Categoria-Almacenamiento : Cod-auto $$=RegresaApCad(yytext); I Cod-register :b$=RegresaApCad(yytext); I Cod-static $$=RegresaApCad(yytext); I Cod-extern $!b=RegresaApCad(yytext); I Cod-typedef $$=RegresaApCad(yytext);

Calificador-De-Tipo : Cod-const $$=RegresaApCad(yyteKt);) I Cod-volatile $$=RegresaApCad(yytext);

Especificador-De-Tipo : Cod-void $$=RegresaApCad(yytext); I Cod-char $$=RegresaApCad(yytext); I Cod-short $$=RegresaApCad(yytext); I Cod-int $$=RegresaApCad(W:ext); I Cod-long $$=RegresaApCad(yytext); 1 Cod-float $$=RegresaApCad(y)text); I Cod-double $$=RegresaApCad(yytext); 1 Cod-signed $$=RegresaApCad(yytext); 1 Cod-FILE $$=RegresaApCad(yytext); I Cod-unsigned $$=RegresaApCad(yytext); I Especificador-Estructura-O-Union $$=$1; I Especificador-Enum $$=Regrc!saApCad(yytext);) I Identificador-typedef $$=Regres.aApCad(yytext);

Declaracion-Tabla : Cod-DEFINE Cod-TABLE Accion(Ccd-TABLE); Cuerpo-Decl-Tabla Cod-punto-coma Escribe-TABLE();

Cuerpo-Decl-Tabla : ldentificador Tabla = RegresaApCad(yytext); Cod-corchete-abre Cod-constante-entera AgregaAListaldNum(Tabla,RegresaNurn(yytext)); Cod-corchete-cierra Cod-igual Cod-llave-abre Lista-Campos Cod-llave-cierra

Declaracion-Campo : Cod-llave-abre Cod-constante-de-caracter Cad-Aux=RegresaApCad(yytext); Cod-coma Tipo-dato-extendido Cod-coma Expresion-Primaria Cod-coma Tipo-lndice Cod-coma Tipo-Valor Cod-llave-cierra Agrega-A-ListaCampos(Tabla,Cad_Aux,lNT($5),$7,lNT($9), INT($ll));

Tipo-lndice : Cod-UNIQUE $$=RegresaAscii(O); I Cod-DUPS $$=RegresaAscii(DUPLlCADO); I Cod-NO $$=RegresaAscii(NO);

Tipo-Valor : Cod-NULLS $$=RegresaAscii(NULOS); I Cod-NONULLS $$=RegresaAscii(O);

Tipo-dato-extendido : Cod-INTEGER $$=RegresaAscii(lNTEGER); I Cod-CHAR $$=RegresaAscii(STRlNG); I Cod-DATE $$=RegresaAscii(STFtlNGDATE); I Cod-BOOLEAN $$=RegresaAscii(ElOOLEAN); I Cod-FLOAT $$=RegresaAscii(FLOAT);

UAM 95

Lista-Campos : Declaracion-Campo I Lista-Campos Cod-coma Declaracion-Campo

Cuerpo-Estructura-O-Union : ldentificador Cad-Aux=RegresaApCad(yytext); CadAux ($3=RegresaApCacl(Cad_Aux); LiberaCad(Cad-Aux); Cod-!lave-abre Lista-Declaraciones-Struct Cod-llave-cierra $3=UneCads($3,"r,1);$3=IJneCads($3,$6,3); $$=UneCads($3,")",1); I Cod-llave-abre Lista-Declaraciones-Struct Cod-llave-cierra $$=Entrc!Llaves($2);

I Identificador $$=RegresaApCad(yytext);

Especificador-Estructura-O-Union : Estructura-O-Union 'Cuerpo-Estructura-O-Union $$=UneCads($l,$2,3);

Estructura-O-Union : Cod-struct $$=RegresaApCad(yytcxt);) I Cod-union $$=RegresaApCad(yytc!xt);

Lista-Declaraciones-Struct : Declaracion-Struct $$=$1; I Lista-Declaraciones-Struct [leclaracion-Struct $$=UneCads($l,$2,3);

Declaracion-Struct : Lista-Calificador-Especifcador Lista--Declaradores-Struct Cod-punto-coma CadAux $4=UneCads($l,$2,3); $$=UneCads($4,";W,l);

Lista-Calif-Espec : Lista-Calificador-Especificador $$=$1; I ($$=NULL;

Lista-Calificador-Especificador : Especificador-De-Tipo Lista-Calif-Espec $$=UneCads($l,$2,3);]

I Calificador-De-Tipo Lista-Calif-Espec $$=UneCads($l,$2,3);

Lista-Declaradores-Struct : Declarador-Struct $$=$1; I Lista-Declaradores-Struct Cod-coma Declarador-Struct $$=CadcomaCad($l,$3);

Declarador-Struct : Declarador $$=$I ; I Declarador-O-Nada Expr-Cte $$=UnseCads($l,$2,3);

Declarador-O-Nada : Declarador $$=$1; I $$=NULL;

Expr-Cte : Cod-dosguntos Declarador $$=UneCads(":",$2,2);

Ident-Enum : Cod-llave-abre Lista-De-Enumerador Cod-llave-cierra $$=EntreLlaves($2); I $$=NULL;

Cuerpo-Enum : Identificador Ident=RegresaApCad(yytext); Ident-Enum $$=UneCads(ldent,$3,3); I Cod-llave-abre Lista-De-Enumerador Cod-llave-cierra $$=EntreLlaves($2);

Especificador-Enum : Cod-enum Cuerpo-Enum $$=UneCads("enum ",$2,2);

Lista-De-Enumerador : Enumerador $$=$1; I Lista-De-Enumerador Cod-coma Enumerador $$=CadcomaCad($l,$3);

Igual-Expr-Cte : Cod-igual Expresion-Constante $$=UneCads(" = ",$2,2); I $$=NULL;

Enumerador : ldentificador Ident=RegresaApCad(yytext); Igual-Expr-Cte $$=UneCads(ldent,$3,3);

Lista-De-Identificadores-O-Nada : Lista-De-ldentificadorw $$=$l ; I $$=NULL;

Declarador : Apuntador Declarador-Directo ($$=UneCads($l,$2,3); I Declarador-Directo $$=$I ;

UAM 96

Cuerpo-Declarador-Directo : Cod-corchete-abre Expresion-Constante-O-Nada Cod-corchete-cierra $$=EntreCorch($2);

I Codpren-abre Lista-De-lclentificadores-O-Nada Cod-paren-cierra $$=EntreParent($2); I Codpren-abre Lista-Tipos-De-Parametro Cod-paren-cierra $$=EntreParent($Z);)

Declarador-Directo : Declarador-Directo Cuerpo-Declaraclor-Directo $$=UneCads($l,$2,3); I Codgren-abre Declarador Codglren-cierra $$=EntreParent($2);) I ldentificador $$=RegresaApCad(yytc?xt);)

Apuntador : C o d g r Lista-Calificadores-De-Tip-O-Nada CadAux $3=UneCads(""',$2,2);) Apuntador-O-Nada S;$=UneCads($3,$5,3);)

Lista-Calificadores-De-Tipo-O-Nada : Lista-Calificadores-De-Tipo $$=$I ;) I $!$=NULL;

Lista-Calificadores-De-Tipo : Calificador-De-Tip $$=$1;) I Lista-Calificadores-De-Tipo Calificador-De-Tipo $$=UneCads($l,$2,3);

Apuntador-O-Nada : Apuntador $$=$I ;) I $$=NULL;)

Coma-O-Nada : Cod-coma $$=RegresaApCad(yytext); I $$=NULL;)

Lista-Tips-De-Parametro : Lista-De-Parametros Puntos.-O-Nada $$=UneCads($l,$2,3);

Puntos-O-Nada : Cod-coma Cod-tres-puntos $$=RegresaApCad(", ...");) I $$=NULL;)

Lista-De-Parametros : Declaracion-Parametro $$=S1 ; I Lista-De-Parametros Cod-coma Declaracion-Parametro $$=CadcomaCad($l,$3);

Cuerpo-Declaracion-Parametro : Declarador $$=$I ;) I Declarador-Abstracto $:;=S1 ;) I $$=NULL;

Declaracion-Parametro : Especificadores-De-Declaracion Cuerpo-Declaracion-Parametro $$=UneCads($l,$2,3);

Lista-De-ldentificadores: Identificador ldent=RegresaApCad(yytext); Agrega-A-Lista(Seccion, Ident);l;$=ldent;

Agrega-A-Lista(Seccion,Ident);$$=CadcomaCad($l )dent); I Lista-De-ldentificadores Cod-coma ldentificador Ident=RegresaApCad(yytext);

Inicializador : Expresion-De-Asignacion $$=$1;)

$$=EntreLlaves($5);) I Cod-llave-abre Lista-De-lnicializadores Coma-O-Nada Cod-llave- cierra CadAux $5=UneCads($2,$3,3);

Lista-De-lnicializadores : Inicializador $$=$1; I Lista-De-Inicializadores Cod-coma Inicializador $$=CadcomaCad($l,$3);

Expresion-Constante-0-Nada : Expresion-Constante $$=:$I ;) I ($$=NULL;

Declarador-Abstracto-Directo : Codgaren-abre Declarador-Abstracto Cod-paren-cierra $$=EntreParen1($2); I Cod-corchete-abre Expre;ion-Constante-O-Nada Cod-corchete-cierra

I Codgren-abre Lista-Tipos-De-Parametro-O-Nada Cod-paren-cierra $$=EntreCorch($2);)

$$=EntreParent($2);)

UAM 97

Lista-Tipos-De-Parametro-O-Nada : Lista-Tipos-De-Parametro $$=S1 ; I $$=NULL;

Declarador-Abstracto : Apuntador Declarador-Abstracto-Directo $$=UneCads($l,$2,3);printf("%s\n",$$); I Declarador-Abstracto-Directo $$:=$1;

Declarador-Abstracto-O-Nada : Declarador-Abstracto $$=$1; I $$=NULL;

Nombre-De-Tipo : Lista-Calificador-Especificador Declarador-Abstracto-O-Nada $$=UneCads($l,$2,3);

Proposicion : Proposicion-Expresion $$=$I ; I Proposicion-Etiquetada $$=$1; I Proposicion-Compuesta $$=$1; I Proposicion-De-Seleccion $$=$1; I Proposicion-De-lteracion $$=$1; 1 Propicion-De-Salto $$=S1 ; I Propicion-Dbase $$=LlamadaDb;

Proposicion-Etiquetada : Cod-case Expresion-Constante CadAux $3=UneCads("case",$2,2); Cod-dos-puntos $3=UneCads($3":",1); Proposicion $$=UneCads($3,$7,3);

I Cod-default Cod-dos-puntos Proposicion $$=UneCads("default :",$3,2);

Proposicion-Expresion : Expresion Cod-punto-coma $$=UneCads($l ,";W,l );] I Cod-punto-coma $$=NULL;

Lista-Proposicion-O-Nada : Lista-De-Proposiciones $$=$I ; I $$=NULL;

Cuerpo-Proposicion-Compuesta : Lista-De-Declaraciones Lista-Proposicion-O-Nada $$=UneCads($l,$2.3); I Lista-De-Proposiciones $$=$1; I $$=NULL;

Proposicion-Compuesta : Cod-llave-abre Cuerpo-Proposicion-Compuesta Cod-llave-cierra $$=EntreLlaves($2);

Lista-De-Proposiciones : Proposicion $$=$1; I Lista-De-Proposiciones Proposicion $$=UneCads($l,$2,3);

Expresion-O-Nada : Expresion $$=$1; I $$=NULL;

Cuerpo-for-Auxiliar : Expresion Cod-punto-coma CadAux $3=UneCads($l ,";h'',l); Expresion-O-Nada $$=UneCads($3.$5.3);

I Codgunto-coma Expresion-O-Nada $$=UneCads(";W,$2,2);

Cuerpo-for : Expresion Cod-punto-coma CadAux $3=UneCads($l ,";W,l); Cuerpo-for-Auxiliar $$=UneCads($3,$5,3); I Codgunto-coma Cuerpo-for-Auxiliar ($$=UneCads(";W,$2,2);

Else-O-Nada : Cod-else Proposicion $$=UneCads("else ",$2,2); I $$=NULL;

Proposicion-De-Seleccion : Cod-if Codgaren-abre Expresion CadAux $3=UneCads("if (",$3,2); Ctd-paren-cierra $3=UneCads($3,")",1); Proposicion $3=UneCads($3,$8.3); Else,-O-Nada $$=UneCads($3,$10,3);

I Cod-switch Cod-paren-abre CadAux Expresion $J=UneCads("switch (",$4,2); Cod-paren-cierra $3=UneCads($3,")",1); Proposicion $$=UneCads($3,$8,3);

UAM 98

Proposicion-De-lteracion : Cod-while Codgaren-abre CadAux Expresion $J=UneCads("while (",$4,2); Codgaren-cierra $3=UneCads($3,")",1]; Proposicion $$=UneCads($3,$8,3);

I Cod-do Proposicion CadAux $3=UneCalds("do ",$2,2); Cod-while Codgaren-abre $3=UneCads($3."while (",2); Expresion $3=UneCads($3,$8,3); Cod-paren-cierra Codgunto-coma $$=UneCads($3,");\rl",l);

I Cod-for Codgaren-abre CadAux Cuerpo-for $3=UneCads("for (",$4,2); Cod-paren-cierra $3=UneCads($3,")",1); Proposicion $$:=UneCads($3,$8,3);

I Cod-FOREACH Accion(Cod-FOREACIi);LineaActual=yylineno; CadAux ldentificador ($3 = ldent = RegresaApCad(yytext); INTO-O-Nada CadAux $7=ConstruyeFOREACH(LineaActual,$3); Proposicion Cod-END Cod-FOREACH ($$=TerminaFOREACH($3,$6,$7,$9);

Proposicion-De-Salto : Cod-continue Codgunto-coma S$=RegresaApCad("continue;\n"); I Cod-break Codgunto-coma $$=RegresaApCad("break; "); I Cod-return Expresion-O-Nada CedAux $3=UneCads("return ",$2,2); Cod-punto-coma $$=UneCads($3,";W,4);

1 Cod_goto CadAux ldentificador $:!=UneCads("goto ",yytext,4); Cod-punto-coma $$=UneCads($2,";W,4);

Expresion : Expresion-De-Asignacion $$=$1; I Expresion Cod-coma Expresion-De-Asignacicn $$=CadcomaCad($l,$3);)

Expresion-De-Asignacion : Expresion-Condicional $$=$'I ; I Expresion-Unuaria Operador-.De-Asignacion CadAux $3=UneCads($l,$2,3);

Expresion-De-Asignacion $t;=UneCads($3,$5,3);

Operador-De-Asignacion : Cod-igual $$=RegresaApCad(yytext); I Cod-por-igual $$=RegresaApCad(yytext); I Cod-entre-igual $$=RegresaApCad(yytext); I Cod-mod-igual $$=RegresaApCad(yytext); I Cod-mas-igual $$=RegresaApCad(yytext); I Cod-menos-igual $$=RegresaApCad(yytext); I Cod-izqigual $$=RegresaApCad(yytext); I Cod-der-igual $$=RegresaApCad(yytext); I Cod-and-igual $$=RegresaAipCad(yytext); I Cod-xor-igual $$=RegresaApCad(yytext); I Cod-or-igual $$=RegresaApCad(yytext);

Expresion-Constante : Expresion-Condicional $$=$1;

Expresion-Condicional : Expresion-Logica-OR $$=$1; I Expresion-Logica-OR Cod-interroga CadAux $3=UneCads($l," ?",1); Expresion $3=UneCads($3,$5,3);) Cod-dor;-puntos $$=UneCads($3,":",1); Expresion-Condicional ($$=UneCads($3,$9,3);

Expresion-Logica-OR : Expresion-Logica-AND $$=$1; I Expresion-Logica-OR Cod-doble-or CadAux ($J=UneCads($l ,''lI'',l); Expresion-Logica-AND $$=UneCads($3,$5,3);

Expresion-Logica-AND : Expresion-OR-Inclusivo $$=U ;) I Expresion-Logia-AND Cod-doble-ampersand CadAux $3=UneCads($l ,"&&",l);

Expresion-OR-Inclusivo $$=UneCads($3.$5,3);

Expresion-OR-Inclusivo : Expresion-OR-Exclusivo $$=$l ; I Expresion-OR-Inclusivo Cod-or CadAux $3=UneCads($l ,''I'',l); Expresion-OR-Exclusivo $$=UneCads($3,$5,3);

Expresion-OR-Exclusivo : Expresion-AND $$=$1;) 1 Expresion-OR-Exclusivo Cod-gorro CadAux $3=UneCads($l ,"A",l); Expresion-AND $$=UneCads($3,$5,3);

UAM 99

Expresion-AND : Expresion-De-Igualdad $$=$1;) I Expresion-AND Cod-ampersand CadAux ($3=UneCads($l,"&",l); Expresion-De-Igualdad $$=UneCads($3.8,3);)

Expresion-De-Igualdad : Expresion-Relaciona1 $$=$1; I Expresion-De-Igualdad Cod-igual-igual CadAux $3=UneCads($l,"==",l);) Expresion-Relaciona1 $$=UneCads($3,$5,3);

I Expresion-De-Igualdad Cod-diferente-igual CadAux $3=UneCads($l,"!=",l); Expresion-Relaciona1 $$=UneCads($3,$5,3);)

Cuerpo-Expresion-Relaciona1 : Cod-menor Expresion-De-Corrimiento $$=UneCads("<",$2,2); I Cod-mayor Expresion-De-Corrimiento $$=UneCads(">",$2,2); I Cod-menor-igual Expresion-De-Corrimiento $$=UneCads("<=",$2,2); I Cod-mayor-igual Expresion-De-Corrirrliento $$=UneCads(">=",$2,2);

Expresion-Relaciona1 : Expresion-De-Corrimiento ($$=S1 ; I Expresion-Relaciona1 Cuerpo-Expresion-Relaciona1 $$=UneCads($l,$2,3);

Expresion-De-Corrimiento : Expresion-Aditiva $$=$1; I Expresion-De-Corrimiento Cuerpo-Expr-De-Corr $$=UneCads($l,$2,3);

Cuerpo-Expr-De-Corr : Cod-corrimiento-izq Expresion-Aditiva $$=UneCads("<<",$2,2); I Cod-corrimiento-der Expresion-Aditiva $$=UneCads("=",$2,2);

Expresion-Aditiva : Expresion-Multiplicativa $$=$1; I Expresion-Aditiva Cod-mas CadAux !63=UneCads($l,"+".l);)

I Expresion-Aditiva Cod-menos CadAux $3=UneCads($l ,"-",l);) Expresion-Multiplicativa $$=UneCads($3,$5.3);

Expresion-Multiplicativa $$=UneCads($3,$5,3);

Expresion-Multiplicativa : Expresion-Cast $$=$1;

$$=UneCads($l,$2,3); I Expresion-Multiplicativa Cuerpo-,Expr-Multip

Cuerpo-Expr-Multip : Cod-por Expresion-Cast $$=UneCads(""',$2,2); I Cod-entre Expresion-Cast ($$=UneCads("r,$2,2);) I Cod-porciento Expresion-Cast $$=IJneCads("%",$2,2);)

Expresion-Cast : Expresion-Unuaria $$=S1 ;) I Codgaren-abre Nombre-De-Tipo CadPux Codgaren-cierra $3=EntreParent($2); Expresion-Cast $$=UneCads($3 ,$6,3);)

Expresion-Unuaria : Expresion-Posfija $$=S1 ;) I Cod-mas-mas Expresion-Unuaria $!b=UneCads("++",$2,2); I Cod-menos-menos Expresion-Unuaria $$=UneCads("-",$2,2); I Operador-Unuario Expresion-Cast ($$=UneCads($l,$2,3); I Cod-sizeof Cod-paren-abre CadAux Nombre-De-Tipo Cod-paren-cierra $3=EntreParent($4);$$=UneCads("sii:eof ",$3,2);

1 Cod-sizeof Expresion-Unuaria $$=UneCads("sizeof ",$2,2);

Operador-Unuario : Cod-ampersand $$=RegresaApCadc,yytext);) 1 Cod-por $$=RegresaApCad(yytext);) I Cod-mas $$=RegresaApCad(y$ext); I Cod-menos $$=RegresaApCad(yytext); I Cod-tilde ($$=RegresaApCad(yytext); 1 I Cod-admira $$=RegresaApCad(yyte,R);

Lista-Expr-Argum-O-Nada : Lista-Expresiones-Argumento $$=$1;) I $$=NULL;

UAM 1 O 0

Lista-Expresiones-Argumento : Expresion-De-Asignacion ($$=$1;) I Lista-Expresiones-Argumento Cod-coma Expresion-De-Asignaciorl ($$=CadcomaCad($l,$3);)

Expresion-Posfija : Expresion-Posfija Cuerpo_Expr_Posfija($$=UneCads($l,$2,3);) I Expresion-Primaria ($$=$I ;)

Cuerpo-Expr-Posfija : Codgaren-abre Lista-Expr-Argum-0-Nada Codgaren-cierra ($$=EntreParent($2);) I Cod-corchete-abre Expresion Cod"corchete_cierra

I Cod-punto ldentificador ($$=UneCads(".",yytext,O);) I Cod-flecha ldentificador ($$=UneCads("->",yytext,O);) I Cod-mas-mas ($$=RegresaApCad(yytext);) I Cod-menos-menos ($$=RegresaApCad(yytext);)

$$=EntreCorch($2);)

Expresion-Primaria : Identificador (if (WHERE != TRUE) $$=RegresaApCad(yytext);

$$=AgregaTabla(yytext);) else

I Constante ($$=$I ;) I Codgaren-abre Expresion Cod-paren-cierra ($$=EntreParent($2);)

Constante : Cod-constante-entera ($$=RegresaApCad(yytext);) I Cod-constante-de-carader ($$=RegresaApCad(yytext);) 1 Cod-constante-flotante ($$=RegresaApCad(yytext); I Cod-constante-enumeracion ($$=RegresaApCad(yytext);)

Proposicion-Dbase : Visualizacion-De-Datos I Funciones-Dbase I Lenguaje-SQL

Funciones-Dbase : FuncionFecha I FuncionCaracteres I FuncionLogicos I FuncionNumerica

FuncionNumerica Cod-COL Codgaren-abre Cod-paren-cierra (FormaLlamadaLib('"COL():");) Cod-ROW Codgaren-abre Cod-paren-cierra (FormaLlamadaLib('"ROW();");) Cod-DAY Codgaren-abre Expresion-Cast Cod-paren-cierra FormaLlamadaLib("DAY(%s);",$3);)

I C ~ ~ - Y E A R Cod-xikn-adre Éxpr&ibnl-Cast Cod-paren-cierra

I Cod-MONTH Codgaren-abre Expresion-Cast Cod-paren-cierra (FormaLlamadaLib('"YEAR(%s);",$3);)

(FormaLlamadaLib("-MONTH(%s);",$3);)

FuncionFecha : Cod-DATECMP Codgaren-abre Expresllon-Cast Cod-coma Expresion-Cast Cod-paren-cierra (FormaLlamadaLib('"DATECMP(%s);",$3,$5);)

Expresion-Cast Codgaren-cierra FormaLlamadaLib('"DATEADDNUM($3,$5);"); I Cod-DATEADDNUM Codgaren-abre Expresion-Cast Cod-coma

FuncionLogicos : Cod-EXFILE Cod-paren-abre Expresion-Cast Codgaren-cierra (FormaLlamadaLib("-EXFILE();");) I Cod-FOUND Cod-paren-abre Cod-paren-cierra (FormaLlamadaLib("-FOUND-");

FuncionCaracteres : Cod-REPLICATE Cod-paren-abre IExpresion-Cast Cod-coma Expresion-Cast Cod-coma Expresion-Cast Codgaren-cierra (FormaLlamadaLib("~REPLlCATE(%s,%s,%s);",$3,$5,$7);

I Cod-RIGHT Codgaren-abre Expresion-Cast Cod-coma Expresion-Cast Cod-paren-cierra (FormaLlamadaLib("-RIGTH(%s,%s)",$3,$5);

I Cod-STUFF Cod-paren-abre Expresion-Cast Cod-coma Expresion-Cast Cod-coma Expresion-Cast Cod-coma (ForrnaLlamadaLib("-STUFF($3,$5,$7,$9);");) Expresion-Cast Cod-coma Expresion-Cast Codgaren-cierra FormaLlamadaLib("");)

I Cod-TRIM Cod-paren-abre Expreslon-Cast Cod-paren-cierra FormaLlamadaLib("-TRIM(%s);",$3);)

UAM 1 o1

I Cod-RTRIM Codgaren-abre Expresion-Cast Cod-coma Expresion-Cast Cod-paren-cierra

I Cod-CINSERT Codgaren-abre Expresion-Cast Cod-coma Expresion-Cast Cod-coma

1 Cod-CDELETE Cod-paren-abre Expresion-Cast Cod-coma Expresion-Cast Cod-coma

I Cod-UPPER Codgaren-abre Expr(esion-Cast Cod-paren-cierra

I Cod-LOWER Codgaren-abre Expl-esion-Cast Cod-paren-cierra

(FormaLlamadaLib('"RTRIM(%s,%s);",$3,$5);

Expresion-Cast Codgaren-cierra (l~ormaLlamadaLib("_CINSERT(%s,%s,%s);",$3,$5,$7);

Expresion-Cast Codgaren-cierra (liormaLlamadaLib("_CDELETE(%s,%s,%s);",$3,$5,$7);

(FormaLlamadaLib('"UPPER(%s);",$3);

(FormaLlamadaLib('"LOWER(%s);",$3);

Visualizacion-De-Datos : Marcos I Captura

Captura : Cod-INPUT ldentificador (LineaActual=yylineno; Variable=RegresaApCad(yytext);Accion(Cod-lNPUT), Cod-FROM ldentificador (Tabla=RegresaApCad(yytext); Lista-Lineas-Captura (EscribelNPUT(LineaActual,$7); Cod-END Cod-INPUT (Accion(Fin-INPUT);

Lista-Lineas-Captura : Linea-Captura (.$$=$1; I Lista-Lineas-Captura Linea-Captura ($$=UI?eCads($l,$2,3);

Lista-Attrib : Cod-ATTRIBUTE Codgaren-abre (Seccion=ATRIBUTOS; Lista-De-ldentificadores Cod-paren-cierra

Linea-Captura : Posicion-Cursor (Seccion=Cod-SAY; Cod-SAY Expresion-Primaria Cod-GET ldentificador (Campocap = RegresaApCad(yytext);/*LlBERAR*/) Lista-Attrib (++NumCampos;$$=FormaLlamadalNPUT($1,$4); VaciarListaCod(ATRIBUT0S);)

Posicion-Cursor : Cod-IN Expresion-Cast Cod-coma Expresion-Cast (Cad~Aux=UneCads($2,",",1);.$$=UneCads(Cad~Aux,$4,3);

Marcos : Cod-BOX Expresion-Primaria Coma-Numero Coma-Numero Coma-Numero Tipo-Marco-O-Nada (FormaLlamadaLib("~Marcos(%s,%s,%s,%s,%s,LlGHTGRAY);",$2,$3,$4,$5,$6)~

Coma-Numero : Cod-coma Expresion-Primaria ($$=Regrc?saApCad($2);

Tipo-Marco-O-Nada : Cod-DOUBLE ($$=RegresaApCacl("l"); I ($$=RegresaApCad("O);

Lenguaje-SQL : SELECT-SQL I DECLARE-SQL I DELETE-SQL I UPDATE-SQL I INSERT-SQL I Crear-Tabla I Abrir-Tabla I Cerrar-Tabla

SELECT-SQL : (Accion(Cod-SELECT);LineaActual = yylineno; Cod-SELECT (Seccion=COLUMNAS; Lista-De-Identificadores-O-Todos (Seccion = INTO; INTO-O-Nada Cod-FROM ldentificador (Tabla=RegresaApCad(yytext); ORDER-O-Nada WHERE-O-Nada TEMP-O-Nada (if (DECLARE == FALSE) (EscribeSELEC:T(LineaActual,Tabla);Seccion=O;Accion(Fin-SELECT);;

Lista-De-Identificadores-O-Todos : Lista-De-ldentificadores I Cod-por (/'Agrega-A-Lista(Seccion,yytext);'/)

DECLARE-SQL : (Accion(Cod-DECLARE);LineaActual2=:yylineno; Cod-DECLARE ldentificador (Ident=RegresaApCad(yytext); Cod-CURSOR Cod-FOR SELECT-SQL (EscribeDECLARE(LineaActual2,Tabla); Accion(Fin-DECLARE);

DELETE-SQL : (Accion(Cod-DELETE);LineaActual = yylineno; Cod-DELETE Seccion=Cod-DELETE; Cod-FROM Identificador uabla=RegresaApCad(yytext); WHERE-O-Nada (EscribeDELETE(LineaActual,Tabla);Accion(Fin-DELETE);Seccion=O;

UAM 102

INSERT-SQL : Accion(Cod-1NSERT);LineaActual = yylirleno; Cod-INSERT Cod-INTO ldentificador Tabla=RegresaApCad(yytext); Cod-VALLIES Cod-paren-abre Seccion=ASIGNACION; ldentificador Variable=RegresaApCad(yytext); Cod-punto Cod-por Cod-paren-cierra EscribelNSERT(Line~ctual,Tabla,Tabla);Accion(Fin-lNSERT); Seccion = O;

UPDATE-SQL : Accion(Cod-UPDATE);LineaActual = yylineno; Cod-UPDATE ldentificador Tabla=RegresaApCad(yytexl:); Cod-SET Cod-paren-abre Seccion=ASIGNACION; Lista-Expresion-De-Asignacion Codgaren-cierra WHERE-O-Nada Esc:ribeUPDATE(LineaActual,Tabla);Accion(Fin-UPDATE); Seccion = O;)

Lista-Expresion-De-Asignacion : Expresion-De-Asignacion (Variable=RegresaApCad($l ); I Lista-Expresion-De-Asignacion Cod-coma Expresion-De-Asignacion Agrega-A-Lista(Seccion,$3);

INTO-O-Nada : Cod-INTO ldentificador $$ = Variable = RegresaApCad(yytext); Secc-INTO = TRUE; I $$ = NULL;

WHERE-O-Nada : Cod-WHERE (CapturaElem=TRUE;'iHERE=TRUE; Cod-paren-abre Expresion Cod-paren-cierra

I CadWhere=EntreParent($4);CapturaE:lem = FALSE;

ORDER-O-Nada : Cod-ORDER Cod-BY Identificador (Orden = RegresaApCad(yytext); I Orden = NULL;

TEMP-O-Nada : Cod-INTO Cod-TEMP ldentificador ArchTempo = RegresaApCad(yytext); I ArchTempo = NULL;

Crear-Tabla : Cod-CREATE Accion(Cod-CREATE);LineaActual = yylineno; ldentificador Tabla=RegresaApCad(yytext); EscribeCREATE(LineaActual,".dbe",-1 ,Tabla,Tabla);LiberaCad(Tabla);

Abrir-Tabla : Cod-OPEN Accion(Cod-0PEN);LineaActual = yylineno; ldentificador (Tabla=RegresaApCad(yytext); EscribeOPEN(LineaActual,".dbe",Tabla,Tat~la);LiberaCad(Tabla);

Cerrar-Tabla : Cod-CLOSE (Accion(Cod-CL0SE);Lineafrctual = yylineno; ldentificador Tabla=RegresaApCad(yytext); EscribeCLOSE(LineaActual,Tabla);

I Cod-CLOSE Accion(Cod-CL0SE);LineaActual = yylineno; Cod-ALL (EscribeCLOSE-ALL(LineaActua1);)

%%

#include "btrv.c" #include "uti1.c"

UAM 1 O 3

1. [Hewlett Packard] H.P.-UX Reference Vol 7 , Section 7 , HP9000 Series 300/800 computers , (1989) .

2. [Brian W. Kernighan,Dennis M. Ritchie],€/ lenguaje de programación C. , Prentice Hall (1991) .

3. [Jordi Abadal] , Dbase I / / Plus , (1 991)

4. [INFORMIX] Developing Applications Using INFORMIX-4GL , Student Guide , (1 989).

5. [ORACLE] Programmer’s Guide to the ORACLE Precompilers , Version 7.3 , (1 990).

6. [Andrew S. Tanenbaum] , Sistemas Cperativos , diseiio e implementación, (1988).

7. [Crafsoft] User’s Guide to the Btrieve, the record manager. Craftsoft Inc. a Novel1 company

UAM 104.

REFERENCIAS:

1. [Hewlett Packard] H.P. -UXRefe~nce Vol 7 , Section 7 , HP9000 series 300/800 computers , (1989) .

2. [Brian W. KernighaqDennis M. Fiitchie],El lenguaje de programación C. , Prentice Hail (1991) .

3. [Jordi Abadal] , Dbase ///Plus , (1991) .

4. [INFORMIX] Developing Applications Using INFORMIX-4GL , Student Guide , (1 989).

5. [ORACLE] Programmer’s Guide to the ORACLE Precompilers , Version 7.3 , (1 990).

6. [Andrew S. Tanenbaum] , Sistemas Cperativos , disefio e implemenfación, (1988).

7. [Crafsoft] UserS Guide to the Btrieve, the record manager. Craftsoft Inc. a Novel1 company

UAM 105

universidad autonoma metropolitana148.206.53.84/tesiuami/uam8543.pdf · antecedentes historicos....

Documents