Diseño De Un Compilador Online Usando Flex Y Bison 4b7029

expr expr -> | <+> expr | <*> expr | El análisis sintáctico intenta generar un árbol sintáctico que encaje con la sentencia de entrada. Para nuestro ejemplo, dicho árbol sintáctico existe y es el de la figura 4

Ilustración 4: Ejemplo de Árbol sintáctico. (Galvez Rojas & Mora Mata, 2005)

El analizador sintáctico tiene como entrada los lexemas que le suministra el analizador léxico y su función es comprobar que están ordenados de forma correcta (dependiendo del lenguaje que queramos procesar). Los dos analizadores suelen trabajar unidos e incluso el léxico suele ser una subrutina del sintáctico. Al analizador sintáctico se le suele llamar párser. El párser genera de manera teórica un árbol sintáctico. Este árbol se puede ver como una estructura jerárquica que para su construcción utiliza reglas recursivas. La estructuración de este árbol hace posible diferenciar entre aplicar unos operadores antes de otros en la evaluación de expresiones. Es decir, si tenemos esta expresión: x = x * y – 2; El valor de x dependerá de si aplicamos antes el operador producto que el operador suma. Una manera adecuada de saber qué operador aplicamos antes es elegir qué árbol sintáctico generar de los dos posibles.

Ilustración 5: Árbol sintáctico 1 (Ruiz Catalan, 2010)

Ilustración 6:Árbol sintáctico 2 (Ruiz Catalan, 2010)

2.3.1. Análisis sintáctico descendente El análisis sintáctico descendente puede verse como el problema de construir un árbol de análisis sintáctico para la cadena de entrada, partiendo desde la raíz y creando los nodos del árbol de análisis sintáctico en preorden (profundidad primero). De manera equivalente, podemos considerar el análisis sintáctico descendente como la búsqueda de una derivación por la izquierda para una cadena de entrada. Ejemplo: La secuencia de árboles de análisis sintáctico en la figura 7 para la entrada id+id*id es un análisis sintáctico descendente, de acuerdo con la gramática, que repetimos a continuación:

E → T E' E'→ + T E' | e T→ F T T ' → ∗ F T'| e F→ ( E ) | id

Esta secuencia de árboles corresponde a una derivación por la izquierda de la entrada. En cada paso de un análisis sintáctico descendente, el problema clave es el de determinar la producción que debe aplicarse para un no terminal, por decir A. Una vez que se elige una producción A, el resto del proceso de análisis sintáctico consiste en “relacionar” los símbolos terminales en el cuerpo de la producción con la cadena de entrada. Ver fig 7.

Ilustración 7:Análisis sintáctico descendente para id+id*id (Aho, Lam, Sethi, & Ullman, 1998)

2.4.

Análisis Semántico Esta fase revisa el árbol sintáctico junto con los atributos y la tabla de símbolos para tratar de encontrar errores semánticos. Para todo esto se analizan los operadores y operandos de expresiones y proposiciones.

Finalmente reúne la información necesaria sobre los tipos de datos para la fase posterior de generación de código. El componente más importante del análisis semántico es la verificación de tipos. Aquí, el compilador verifica si los operandos de cada operador son compatibles según la especificación del lenguaje fuente. Si suponemos que nuestro lenguaje solo trabaja con números reales, la salida de esta fase sería su mismo árbol, excepto porque el atributo de , que era el entero 8 a la entrada, ahora pasaría a ser el real 8,0. Además se ha debido controlar que las variables implicadas en la sentencia, a saber, comision, fijo y valor son compatibles con el tipo numérico de la constante 8,0. 2.4.1. Traducción dirigida por la sintaxis Es importante destacar que el analizador sintáctico tiene el control en todo momento, y el léxico por trozos, a petición del sintáctico. En otras palabras, el sintáctico va construyendo su árbol poco a poco (de izquierda a derecha), y cada vez que necesita un nuevo componente léxico para continuar dicha construcción, se lo solicita al lexicográfico; éste lee nuevos caracteres del fichero de entrada hasta conformar un nuevo componente y, una vez obtenido, se lo suministra al sintáctico, quien continúa la construcción del árbol hasta que vuelve a necesitar otro componente, momento en que se reinicia el proceso. Este mecanismo finaliza cuando se ha obtenido el árbol y ya no hay más componentes en el fichero de entrada, o bien cuando es imposible construir el árbol. Esto es tan sólo el principio de lo que se denomina compilación dirigida por sintaxis (ver figura 5): es aquél mecanismo de compilación en el que el control lo lleva el analizador sintáctico, y todas las demás fases están sometidas a él.

Ilustración 8: Traducción dirigida por la sintaxis. (Galvez Rojas & Mora Mata, 2005)

2.4.2. Atributos Un atributo es cualquier cantidad asociada con una construcción de programación. Algunos ejemplos de atributos son los tipos de datos de las expresiones, el número de instrucciones en el código generado, o la ubicación de la primera instrucción en el código generado para una construcción, entre muchas otras posibilidades. Como utilizamos símbolos de la gramática (no terminales y terminales) para representar las construcciones de programación, extendemos la noción de los atributos, de las construcciones a los símbolos que las representan.

2.4.3. Notaciones para asociar reglas semánticas 2.4.3.1.

Definición dirigida por la sintaxis Es una gramática libre de contexto, junto con atributos y reglas. Los atributos sintetizados se asocian con los símbolos gramaticales y las reglas se asocian con las producciones. Si X es un símbolo y a es uno de sus atributos, entonces escribimos X.a para denotar el valor de a en el nodo específico de un árbol de análisis sintáctico, etiquetado como X. Si implementamos los nodos del árbol de análisis sintáctico mediante registros u objetos, entonces los atributos de X pueden implementarse mediante campos de datos en los registros, que representen los nodos para X. Los atributos pueden ser de cualquier tipo: por ejemplo, números, tipos, referencias de tablas o cadenas. Las cadenas pueden incluso ser secuencias largas de código,

por decir código tenemos el lenguaje intermedio utilizado por un compilador. Ver figura 9.

Ilustración 9: Definición orientada por la sintaxis de una calculadora de escritorio simple. (Aho, Lam, Sethi, & Ullman, 1998)

2.4.3.2.

Esquemas de traducción Un esquema de traducción es una notación para unir los fragmentos de un programa a las producciones de una gramática. Los fragmentos del programa se ejecutan cuando se utiliza la producción durante el análisis sintáctico. El resultado combinado de todas estas ejecuciones de los fragmentos, en el orden inducido por el análisis sintáctico, produce la traducción del programa al cual se aplica este proceso de análisis/síntesis. Ver figura10.

Ilustración 10: Implementación de un esquema de traducción orientado. (Aho, Lam, Sethi, & Ullman, 1998)

2.5.

Generación de código intermedio Después de la etapa de análisis, se suele generar una representación intermedia explícita del programa fuente. Dicha representación intermedia se puede considerar como un programa para una máquina abstracta. Cualquier representación intermedia debe tener dos propiedades importantes; debe ser fácil de generar y fácil de traducir al código máquina destino. Así, una representación intermedia puede tener diversas formas. En el presente ejemplo se trabajará con una forma intermedia llamada “código de tres direcciones”, que es muy parecida a un lenguaje ensamblador para un microprocesador que carece de registros y sólo es capaz de trabajar con direcciones de memoria y literales. En el código de tres direcciones cada instrucción tiene como máximo tres operandos. Siguiendo el ejemplo propuesto, se generaría el siguiente código de tres direcciones: t1 = 8.0 t2 = valor * t1 t3 = fijo + t2 comision = t3 De este ejemplo se pueden destacar varias propiedades del código intermedio escogido: • Cada instrucción de tres direcciones tiene a lo sumo un operador, además de la asignación. • El compilador debe generar un nombre temporal para guardar los valores intermedios calculados por cada instrucción: t1, t2 y t3. • Algunas instrucciones tienen menos de tres operandos, como la primera y las últimas instrucciones del ejemplo.

2.6.

Generación de código final Esta fase trata de mejorar el código intermedio, de modo que en la siguiente fase resulte un código de máquina más rápido de ejecutar. Algunas optimizaciones son triviales. En nuestro ejemplo hay una forma mejor de realizar el cálculo de la comisión, y pasa por realizar sustituciones triviales en la segunda y cuarta instrucciones, obteniéndose: t2 = valor * 8.0 comision= fijo + t2

El compilador puede deducir que todas las apariciones de la variable t1 pueden sustituirse por la constante 8,0, ya que a t1 se le asigna un valor que ya no cambia, de modo que la primera instrucción se puede eliminar. Algo parecido sucede con la variable t3, que se utiliza sólo una vez, para transmitir su valor a comisión en una asignación directa, luego resulta seguro sustituir comisión por t3, a raíz de lo cual se elimina otra de las líneas del código intermedio.

2.7.

Tablas de Símbolos y tipos Ponemos aquí esta sección, aunque no es una fase del proceso de compilación, porque es una parte muy importante de todo el proceso. La tabla de símbolos es una estructura de datos auxiliar donde se va a guardar información sobre las variables declaradas, las funciones y procedimientos, sus nombres, sus parámetros y en generar cuanta información vaya a ser necesaria para realizar todo el proceso de compilación. La tabla de tipos no es menos importante, ya que va a guardar información tanto sobre los tipos básicos como sobre los tipos definidos en el programa a compilar. El compilador debe tener a estas tablas a lo largo de todo el proceso de compilación. Además, el número de s suele ser alto, por lo que es conveniente optimizar la estructura de estas tablas para que su manipulación sea lo menos costosa en tiempo y así reducir el tiempo de compilación (aunque no habrá variación en el tiempo de ejecución del programa compilado ya que el proceso de manipulación de las tablas de tipos y símbolos se hace en tiempo de compilación).

2.8.

Manejo de Errores El manejo de errores es vital para el proceso ya que informa al programador dónde hay errores, de qué tipo son, etc. Cuanta más información sea capaz de dar al programador, mejor. Por lo tanto, no hay que dejar atrás este aspecto del proceso de compilación. La detección de errores no siempre es posible en la fase en que se producen, algunas veces se detectarán en fases posteriores y algunos de ellos no se podrán detectar ya que se producirán en el tiempo de ejecución (serán responsabilidad del programador que ha realizado el código fuente). Generalmente, es en las fases de análisis sintáctico y semántico donde suelen aparecer y es importante que el proceso no se pare al encontrar

un error, sino que continúe su proceso de análisis hasta el final y luego informe de todos los errores encontrados

2.9.

Herramientas de construcción de compiladores Al igual que cualquier desarrollador de software, el desarrollador de compiladores puede utilizar para su beneficio los entornos de desarrollo de software modernos que contienen herramientas como editores de lenguaje, depuradores, es de versiones, profilers, ambientes seguros de prueba, etcétera. Además de estas herramientas generales para el desarrollo de software, se han creado otras herramientas más especializadas para ayudar a implementar las diversas fases de un compilador. Estas herramientas utilizan lenguajes especializados para especificar e implementar componentes específicos, y muchas utilizan algoritmos bastante sofisticados. Las herramientas más exitosas son las que ocultan los detalles del algoritmo de generación y producen componentes que pueden integrarse con facilidad al resto del compilador. Algunas herramientas de construcción de compiladores de uso común son: 1. Generadores de analizadores sintácticos (parsers), que producen de manera automática analizadores sintácticos a partir de una descripción gramatical de un lenguaje de programación. 2. Generadores de escáneres, que producen analizadores de léxicos a partir de una descripción de los tokens de un lenguaje utilizando expresiones regulares. 3. Motores de traducción orientados a la sintaxis, que producen colecciones de rutinas para recorrer un árbol de análisis sintáctico y generar código intermedio. 4. Generadores de generadores de código, que producen un generador de código a partir de una colección de reglas para traducir cada operación del lenguaje intermedio en el lenguaje máquina para una máquina destino. 5. Motores de análisis de flujos de datos, que facilitan la recopilación de información de cómo se transmiten los valores de una parte de un programa a cada una de las otras partes.

El análisis de los flujos de datos es una parte clave en la optimización de código. 6. Kits (conjuntos) de herramientas para la construcción de compiladores, que proporcionan un conjunto integrado de rutinas para construir varias fases de un compilador. 2.10.

Herramienta para generar analizadores léxicos Flex Flex es un una herramienta que permite generar analizadores léxicos. A partir de un conjunto de expresiones regulares, Flex busca concordancias en un fichero de entrada y ejecuta acciones asociadas a estas expresiones. Es compatible casi al 100% con Lex, una herramienta clásica de Unix para la generación de analizadores léxicos, pero es un desarrollo diferente realizado por GNU bajo licencia GPL. Los ficheros de entrada de Flex (normalmente con la extensión .l) siguen el siguiente esquema: %% patrón1 {acción1} patrón2 {acción2} ... donde: patrón: expresión regular acción: código C con las acciones a ejecutar cuando se encuentre concordancia del patrón con el texto de entrada Flex recorre la entrada hasta que encuentra una concordancia y ejecuta el código asociado. El texto que no concuerda con ningún patrón lo copia tal cual a la salida. Por ejemplo: %% a*b {printf(“X”);}; re ; El ejecutable correspondiente transforma el texto: abre la puertaab en X la puertX pues ha escrito X cada vez que ha encontrado ab o aab y nada cuando ha encontrado re.Flex lee los ficheros de entrada dados, o la entrada estándar si no se le ha indicado ningún nombre de fichero, con la descripción de un escáner a generar. La descripción se encuentra en forma de parejas de

expresiones regulares y código C, denominadas reglas. Flex genera como salida un fichero fuente en C, ‘lex.yy.c’, que define una función ‘yylex()’. Este fichero se compila y se enlaza con la librería de Flex para producir un ejecutable. Cuando se arranca el fichero ejecutable, este analiza su entrada en busca de casos de las expresiones regulares. Siempre que encuentra uno, ejecuta el código C correspondiente.

2.10.1. Estructura de un fichero Flex El fichero de entrada de Flex está compuesto de tres secciones, separadas por una línea donde aparece únicamente un ‘%%’ en esta: definiciones %% reglas %% código de

2.10.1.1. La sección de definiciones Esta sección del archivo contiene la declaración Lex en C para incluir el archivo (y.tab.h) producido por Yacc / Bison que contiene las definiciones de la del fichas de varios caracteres. La primera sección también contiene definiciones Lex utilizados en las expresiones regulares. En este caso, DIGIT se define como uno de los símbolos del 0 al 9 y el ID se define para ser una letra minúscula seguida de cero o más letras o dígitos. 2.10.1.2. La sección de reglas La segunda sección del archivo Lex da las expresiones regulares para cada ficha ser reconocido y una acción correspondiente. Las cadenas de uno o más dígitos se reconocen como un entero y por lo tanto el valor INT se devuelve al analizador. Las palabras reservadas del lenguaje son una cadena de letras en minúscula (mayúscula pueden ser utilizados, pero deben ser tratados de manera diferente). Los espacios en blanco, tabuladores y saltos de línea se ignoran. Todos los demás símbolos de caracteres solo se devuelven como ellos mismos (los lugares de entrada de escáner todo en el yytext cadena).

2.10.1.3. La sección de código de Esta sección suele estar vacia pero puede contener código C asociado con las acciones.

2.11. Herramienta para generar analizadores sintácticos Bison Bison es un generador de analizadores sintácticos de propósito general que convierte una descripción para una gramática independiente del contexto (en realidad de una subclase de éstas, las LALR) en un programa en C que analiza esa gramática. Es compatible al 100% con Yacc, una herramienta clásica de Unix para la generación de analizadores léxicos, pero es un desarrollo diferente realizado por GNU bajo licencia GPL. Todas la gramáticas escritas apropiadamente para Yacc deberían funcionar con Bison sin ningún cambio. Usándolo junto a Flex esta herramienta permite construir compiladores de lenguajes. Un fuente de Bison (normalmente un fichero con extensión .y) describe una gramática. El ejecutable que se genera indica si un fichero de entrada dado pertenece o no al lenguaje generado por esa gramática.

2.11.1.

Estructura de Bison La forma general de una gramática de Bison es la siguiente: %{ declaraciones en C y en Bison %} Reglas gramaticales y acciones %% Código C adicional Los ‘%%’, ‘%{‘ y ‘%}’ son signos de puntuación que aparecen en todo archivo de gramática de Bison para separar las secciones.

2.11.1.1.

Declaraciones en C y en Bison La primera sección del archivo Bison consiste en una lista de tokens (distintos de los caracteres individuales) que se espera por el analizador y la especificación del símbolo inicial de la gramática. Esta sección del archivo Yacc puede contener la

especificación de la precedencia y asociatividad de los operadores. Esto permite una mayor flexibilidad en la elección de una gramática libre de contexto. Suma y la resta se declaran a quedar asociativo y de prioridad más baja, mientras que la potencia se declara como asociativa derecha y tener la más alta prioridad. 2.11.1.2.

Reglas gramaticales y acciones La segunda sección del archivo Bison consiste en la gramática independiente del contexto para el idioma. Producciones están separados por punto y coma, el símbolo ':: =' del BNF se reemplaza por ':', la producción de vacío se deja vacío, no terminales se escriben en minúsculas, y los símbolos terminales de varios caracteres en mayúsculas. Note la simplificación de la gramática de expresión debido a la separación de precedencia de la gramática.

2.11.1.3.

Código C adicional La tercera sección del archivo Bison consiste en código C. Debe haber un main() que llama a la función yyparse (). La función yyparse () es la rutina de controlador para el analizador. También debe existir la función yyerror() que se utiliza para informar de errores durante el análisis sintáctico.

2.12. Un Servidor Web Un servidor web o servidor HTTP es un programa informático que procesa una aplicación del lado del servidor, realizando conexiones bidireccionales y/o unidireccionales y síncronas o asíncronas con el cliente y generando o cediendo una respuesta en cualquier lenguaje o Aplicación del lado del cliente. El código recibido por el cliente suele ser compilado y ejecutado por un navegador web. Para la transmisión de todos estos datos suele utilizarse algún protocolo. Generalmente se usa el protocolo HTTP para estas comunicaciones, perteneciente a la capa de aplicación del modelo OSI. El término también se emplea para referirse al ordenador que ejecuta el programa.

Capítulo 3: Desarrollo 3.1.

Análisis Léxico

3.1.1. Definición de tokens Tabla 1: Definición de tokens para el analizador sintáctico

Token

Patrón

T_FLOAT

[0-9]+\.[0-9]

T_INT

[0-9]+

T_NEWLINEA

;

T_MAS

+

T_MENOS

-

T_POR

*

T_DIVIDE

/

T_PARENT_IZQ

(

T_PARENT_DER

)

T_QUIT

Exit,quit

N° 1 2 3 4 5 6 7 8 9 10

3.1.2. Implementación en FLEX

Para la implementación del analizador sintáctico vamos a usar Flex, de manera que debe estar instalado en su computadora. Creamos un archivo al que llamaremos calc.l, dentro de el agregamos las siguientes líneas de código. Declaraciones en C Contiene las librerías a usar al momento de generar el analizador lexico, como podemos observar incluye la librería “calc.tab.h”, esta librería será generada al momento de usar Bison y contiene todos los tokens que también serán definidos en el análisis sintáctico.

La función yylex() será la que se encargara de leer el archivo y retornar el siguiente token. %{ #include <stdio.h> #define YY_DECL int yylex() #include "calc.tab.h" %}

Definición de Reglas Aquí se definirán los patrones y tokens respectivos guiándonos de la tabla 1, en donde especificamos los tokens que vamos a usar, la opción noyywrap se define para que flex solo lea un fichero de entrada. La variable yylval es una variable global y es usada tanto por flex como por bison, se encarga de almacenar información adicional como el nombre del identificador y su tipo de dato. %} %option noyywrap ignora " "|\t|\n %%

{ignora}* {;} [0-9]+\.[0-9]+

{yylval.fval = atof(yytext); return T_FLOAT;}

[0-9]+

{yylval.ival = atoi(yytext); return T_INT;}

";"

{return T_NEWLINEA;}

"+"

{return T_MAS;}

"-"

{return T_MENOS;}

"*"

{return T_POR;}

"/"

{return T_DIVIDE;}

"("

{return T_PARENT_IZQ;}

")"

{return T_PARENT_DER;}

"exit"

{return T_QUIT;}

"quit"

{return T_QUIT;}

. %%

{printf("Error\n");}

3.2.

Análisis Sintáctico

3.2.1. Definición de Gramáticas libres del Contexto Las gramáticas a usar serán las siguientes. Tabla 2: Definición de la gramática libre del contexto y reglas semánticas

Reglas Semánticas

Producciones → Ԑ | → T_NEWLINEA | <expr_mixta>.T_NEWLINEA | <expr> T_NEWLINEA | T_QUIT T_NEWLINEA

{ printf("%f\n", expr_mixta.valor);} { printf("%i\n", expr.valor); } {printf("bye!\n"); exit(0); }

<expr_mixta>.→ T_FLOAT | <expr_mixta>.T_MAS <expr_mixta>. |<expr_mixta>.T_MENOS <expr_mixta>. |<expr_mixta> T_POR <expr_mixta> |<expr_mixta> T_DIVIDE <exprn_mixta> |T_PARENT_IZQ <expr_mixta> T_PARENT_DER |<expr > T_MAS <expr_mixta> |<expr> T_MENOS <expr_mixta> |<expr> T_POR <expr_mixta> |<expr > T_DIVIDE <exprn_mixta> |<expr_mixta> T_MAS <expr > |<expr_mixta> T_MENOS <expr > |<expr_mixta> T_POR <expr > |<expr_mixta> T_DIVIDE <exp > |<expr > T_DIVIDE <expr >

{ <expr_mixta>.valor = T_float.Valor; } { <expr_mixta>.valor = <expr_mixta>.valor + <expr_mixta>.valor} { <expr_mixta>.valor = <expr_mixta>.valor - <expr_mixta>.valor} { <expr_mixta>.valor = <expr_mixta>.valor * <expr_mixta>.valor} { <expr_mixta>.valor = <expr_mixta>.valor / <expr_mixta>.valor} { <expr_mixta>.valor = (<expr_mixta>.valor)} { <expr_mixta>.valor = <expr> + <expr_mixta>} { <expr_mixta>.valor = <expr> - <expr_mixta>} { <expr_mixta>.valor = <expr> * <expr_mixta>} { <expr_mixta>.valor = <expr> / <expr_mixta>} { <expr_mixta>.valor = <expr_mixta> + <expr>} { <expr_mixta>.valor = <expr_mixta> - <expr>} { <expr_mixta>.valor = <expr_mixta> * <expr>} { <expr_mixta>.valor = <expr_mixta> / <expr>} { <expr_mixta>.valor = <expr> / (float)<expr>}

<expresión> → T_INT |<expr > T_MAS <expr> |<expr > T_MENOS <expr> |<expr > T_POR <expr> |T_PARENT_IZQ <expr> T_PARENT_DER

{<expr>.valor = T_INT.valor; } {<expr>.valor = <expr>.valor + <expr>.valor } {<expr>.valor = <expr>.valor - <expr>.valor} {<expr>.valor = <expr>.valor* <expr>.valor} {<expr>.valor =<expr>.valor}

3.2.2. Implementación en BISON Para la implementación del analizador sintáctico debemos tener instalado BISON, luego vamos a crear un archivo y lo llamaremos “calc.y” dentro de este archivo agregaremos el siguiente código, manteniendo la estructura de un archivo en Bison.

Declaraciones en C La primera parte del archivo corresponde a la asignación de directivas que vamos a usar en la generación de nuestro analizador sintáctico,

La función yylex() como vimos también fue declarada en el archivo “calc.l” y será la que se encargara de dar el siguiente token. La función yyparse() es el controlador de rutinas del analizador sintáctico. La variable yyin hace referencia al archivo que vamos a leer. La función yyerror() es la encargada de capturar los errores que se pueden producir en el analizador sintactico. %{ #include <stdio.h> #include <stdlib.h> extern int yylex(); extern int yyparse(); extern FILE* yyin;

void yyerror(const char* s); %} Declaraciones en Bison Seguidamente vamos a declarar todos los tokens que declaramos en el analizador léxico. La declaración de %union es la que contiene todas las declaraciones de tipos que vamos a usar en este caso solo vamos a usar valores enteros y flotantes. También vamos a declarar el no terminal inicial %calcular. %union { int ival; float fval; } %token T_INT %token T_FLOAT %token

T_MAS

T_MENOS

T_PARENT_DER %token T_NEWLINEA T_QUIT %left T_MAS T_MENOS %left T_POR T_DIVIDE %type expresion %type expresion_mixta

%start calcular

T_POR

T_DIVIDE

T_PARENT_IZQ

Declaración de las Reglas Sintácticas y Semánticas Aquí vamos a ingresar nuestras gramáticas libres del contexto definidas en la tabla 2, la única diferencia es que en lugar de usar una flecha para la producción se usara los dos puntos “:”. Adicionalmente usaremos la traducción dirigida por la sintaxis llamada esquemas de traducción, que consiste en agregarle a la gramática libre del contexto una regla semántica entre llaves. Guiándonos de la tabla 2 en donde están definidas cambiamos la cabeza de cada producción por “$$” y a los valores siguientes por “$i” dependiendo de su posición.

%% calcular: | calcular linea ; linea: T_NEWLINEA | expresion_mixta T_NEWLINEA { printf("%f\n", $1);} | expresion T_NEWLINEA { printf("%i\n", $1); } | T_QUIT T_NEWLINEA { printf("bye!\n"); exit(0); } ; expresion_mixta: T_FLOAT

{ $$ = $1; }

| expresion_mixta T_MAS expresion_mixta

{ $$ = $1 + $3; }

| expresion_mixta T_MENOS expresion_mixta

{ $$ = $1 - $3; }

| expresion_mixta T_POR expresion_mixta { $$ = $1 * $3; } | expresion_mixta T_DIVIDE expresion_mixta

{ $$ = $1 / $3; }

| T_PARENT_IZQ expresion_mixta T_PARENT_DER

{ $$ =

$2; }

;

| expresion T_MAS expresion_mixta

{ $$ = $1 + $3; }

| expresion T_MENOS expresion_mixta

{ $$ = $1 - $3; }

| expresion T_POR expresion_mixta

{ $$ = $1 * $3; }

| expresion T_DIVIDE expresion_mixta

{ $$ = $1 / $3; }

| expresion_mixta T_MAS expresion

{ $$ = $1 + $3; }

| expresion_mixta T_MENOS expresion

{ $$ = $1 - $3; }

| expresion_mixta T_POR expresion

{ $$ = $1 * $3; }

| expresion_mixta T_DIVIDE expresion

{ $$ = $1 / $3; }

| expresion T_DIVIDE expresion

{ $$ = $1 / (float)$3; }

expresion: T_INT | expresion T_MAS expresion

{ $$ = $1; } { $$ = $1 + $3; }

| expresion T_MENOS expresion { $$ = $1 - $3; } | expresion T_POR expresion

{ $$ = $1 * $3; }

| T_PARENT_IZQ expresion T_PARENT_DER

{ $$ = $2; }

;%% Declaración de código C adicional En esta parte de la declaración vamos a agregar la función main() que es la que va a llamar a todo el programa, main recibe como parámetros argumentos, lo cual es muy beneficioso al momento de ejecutar una consulta desde el entorno web. Luego se da inicio con la variable yyin que es la que apunta al archivo fuente. Adicionalmente se implementa la función yyerror declarada al inicio del archivo. %% int main(int argc, char *argv[]) { if ((yyin = fopen(argv[1], "rt")) == NULL)

/*yyin:variable que apunta al

archivo fuente */ printf("\nNo se puede abrir el archivo: %s\n", argv[1]); else yyparse(); fclose(yyin); return 0; } void yyerror(const char* s) { fprintf(stderr, "%s\n", s); exit(1); }

3.3.

Compilación del programa Para ejecutar el programa en necesario abrir la consola de comandos y teclear lo siguiente: 1. Bison –dy calc.y 2. Flex calc.l 3. Gcc calc.tab.y lex.yy.c – o programa

En la primera instrucción bison creara dos archivos uno será “calc.tab.c” el cual es el archivo del analizador sintáctico, también creara “calc.tab.h” la librería que incluimos en el analizador léxico y que contiene todas las declaraciones de los tokens en el analizador sintáctico. En la segunda instrucción se nos creara un archivo “lex.yy.c” el cual es el analizador léxico generado. En la tercera instrucción generaremos nuestro archivo binario que se llamara “programa” el cual será ya nuestro compilador. Ahora para probarlo bastara con crear un archivo txt y ejecutarlo desde la línea de comandos de la siguiente manera >- programa entrada.txt

3.4.

Creación de proyecto web y funcionamiento online

Para el uso del compilador en un ambiente web utilizaremos el lenguaje de servidor PHP, asi mismo para el rápido desarrollo se realizó con le framework Laravel.

Los requerimientos necesarios para crear el proyecto son: 

Composer: Es un manejador de dependencias de PHP que nos permitirá crear un proyecto con el framework Laravel rápidamente.



Git: Sistema de control de versiones, nos servirá para poder hacer un despliegue a nuestra servidor.



Heoku Toolbet: Es un CLI (Comand Line Interface) que nos proporciona Heroku para la creación del proyecto y sus configuraciones remotas



Entorno local LAMP: Para el desarrollo y prueba en ambiente local.

3.4.1. Pasos para crear el proyecto 1. Crear el proyecto en Laravel mediante composer, ejecutando el siguiente comando 

composer créate-project laravel/larevel livecompiler -–preferdist 5.1

2. Realizar el primer commit del proyecto con los siguientes comandos  git add –A  git commit –m “Creacion de proyecto”

3.4.2. Explicación del funcionamiento del proyecto

Lo dividiremos en 2 partes 

Vista de cliente



Controlador del servidor

Vista de cliente

Ilustración 11: Codigo HTML de la vista

Creamos un formulario con un campo textarea donde escribiremos nuestro código. El botón de submit estará controlador por un función de javascript que ejecutara un método Ajax asíncrono hacia el servidor, esto hará que nos nuestra página se mantenga y no recargue, de igual forma se recibirá los datos de respuesta en un formato JSON el cual será convertido a un objeto de javascript y posteriormente será mostrado en forma de líneas en el segundo textarea situado a lado derecho.

Ilustración 12: Interfaz de Compilador Online

3.4.3. Controlador de servidor

Ilustración 13: Codigo php para el control del servidor

Antes de explicar el funcionamiento de este, se necesita mencionar que el ejecutable generado que hara la compilación de nuestras palabras que enviaremos tiene que estar guardado en algún directorio de nuestro proyecto el del servidor. En nuestro caso optamos por guardarlo en el directorio storage/compiler/ejecutable. pasaremos a explicar lo que necesita.

Teniendo

en

cuenta

lo

anterior

PHP dispone una función llamada exec que tiene como parámetro de entrada un string que será un comando de línea y nos devuelve un array de string con las posibles salidas que causaría el comando al ejecutar en la línea de comandos. Para nuestro caso necesitamos el siguiente comando gcc ./ejecutable

/path/codesource.txt

Como se puede apreciar se necesita como parámetro un string con el nombre del archive del código fuente, éste se creara al recibir la petición desde el cliente con un nombre de tipo hash generado aleatoriamente de longitud 16 con un helper que nos proporciona el framework así mismo como el guardado. $code = $request->get('code'); $filename = str_random(16); Storage::disk('local')->put($filename, $code);

Ejecutamos la función de php exec, pasando el comando que no hará la compilación de nuestro archive fuente. $cmd = "./../storage/compiler/ejecutable ../storage/app/" . $filename; exec($cmd, $out);

La variable $out será la que contendrá la salida de la compilación y ejecución, esto será lo que devolveremos en formato JSON hacia el cliente. 3.4.4.

Despliegue de la aplicación hacia servidor (Heroku)

Antes de ejecutar los comandos proporcionados en necesario tener una cuenta en esta plataforma. 

Creación de la aplicación Heroku despliegue, mediante la línea de comandos ejecutamos lo siguiente  heroku  heroku créate livecompiler  git push heroku master



Configuración de clave de aplicación en heroku  heroku config:set=[hash de 16 digitos]



Podemos visualizar el proyecto desde http://livecompiler.herokuapp.com o ejecutar el comando para que se nos abra directamente.  heroku open

Conclusiones -

Se logró implementar un pequeño compilador online, que realiza consultas mediante una interfaz web y está disponible para cualquier aparato electrónico que pueda conectarse a internet.

-

Se logró establecer un lenguaje de programación que usa operaciones básicas.

-

Se logró generar el analizador léxico a partir de Flex.

-

Se logró generar el analizador sintáctico y semántico a partir de Bison.

-

Se estudió y puso en práctica la traducción dirigida por la sintaxis usando esquemas de traducción.

-

Se logró implantar el compilador en el servidor web.

Recomendaciones Se recomienda a los lectores de este informe ampliar la gramática libre del contexto y así poder realizar más operaciones, funciones y tipos de variables y conseguir una mejor abstracción, también se puede agregar una tabla de símbolos, una máquina de pila y un generador de código, con el cual se puede tener una abstracción más completa de la implementación de los compiladores.

Glosario Lenguaje de Programación: según DRAE. Conjunto de signos y reglas que permite la comunicación con un ordenador. Alfabeto: Conjunto no vacío de símbolos Cadena: secuencias de caracteres formados a partir de símbolos. Gramática: mecanismo que nos permite generar un lenguaje. Derivación: proceso que consiste en sustituir el lado izquierdo por su lado derecho Sentencia: cadena generada a partir de una gramática. Sintaxis: la forma o estructura de las expresiones, declaraciones y unidades de programa. Semántica: el significado de las expresiones, declaraciones, y unidades de programas. Notación BNF. Método más ampliamente conocido para describir la sintaxis de un lenguaje de programación.

Bibliografía

Aho, A., Lam, M., Sethi, R., & Ullman, J. (1998). Compiladores: Principios, Tecnicas y Herramientas 2 Edicion. New Jersey: Pearson. Bejar Hernandez, R. (20 de 07 de 2016). Universidad de Zaragoza- Introduccion a Flex y Bison. Obtenido de http://webdiis.unizar.es/asignaturas/LGA/material_2004_2005/Intro_Flex_Bison. pdf Galvez Rojas, S., & Mora Mata, M. A. (2005). TRADUCTORES Y COMPILADORES CON LEX/YACC, JFLEX/CUP Y JAVACC. Malaga: Universidad de Malaga. Ruiz Catalan, J. (2010). Compiladores: Teoria e Implementacion. Madrid: Graficas DEVA S.L.

Anexo 1: Herramientas necesarias Puedes descargar las herramientas Flex y Bison en la siguiente dirección:

Flex: -

Ingresar al siguiente link: http://gnuwin32.sourceforge.net/packages/flex.htm

-

Descargar la última versión

Bison: -

Ingresar al siguiente link: http://gnuwin32.sourceforge.net/packages/bison.htm

-

Descargar la ultima version

MinGW: -

MinGw es un compilador del lenguaje C/C++, trae librerías necesarias para la ejecución de programas en C/C++

-

Ingresar en el siguiente link

-

http://www.mingw.org/category/wiki/

-

Descargar la versión para tu tipo de arquitectura x86 o x64

Diseño De Un Compilador Online Usando Flex Y Bison 4b7029

Overview 26281t

More details 6y5l6z

Related Documents 3h463d

Flex And Bison 51x1l

Ejemplo Flex Bison Tiposvalores 4820f

Manual Flex Y Bison Con Qt 3h254q

Fases Y Componentes De Un Compilador 306k2f

Compilador Y Enlazador 352g2v

Adobe Flex 3 - Curso Online 146h5v

More Documents from "Joel Cesar Fernandez Segura" s602g

4p345f

Narrative Report On Earthquake And Fire Drill 6m1hv

4p345f

Matriz De Riesgo De Farmacias 4uz5u

Inicio Del Gobierno De Trujillo 493h6c

Surgimiento De La Prensa En La Republica Dominicana 3e5g70