Facultad de Ciencias Físicas y Matemáticas Escuela de Informática
DISEÑO E IMPLEMENTACIÓN DE UN COMPILADOR COMPILADOR ONLINE
Autores: 1052700911 – CRUZ OTINIANO, José Martin 1052700511 - FERNÁNDEZ SEGURA, Joel Cesar
Asesor: José Luis Peralta Lujan
Trujillo, Julio del 2016
Resumen El presente informe está enfocado al diseño e implementación de un compilador online con el propósito de poder realizar cálculos y prueba de escritorio de algoritmos usando un lenguaje de programación sencillo. Para desarrollarlo es necesario usar las herramientas Flex y Bison los cuales se encargan de generar código para analizadores léxicos y sintácticos respectivamente. Para el diseño y la implementación se tiene que tener la siguiente estructura la cual abarca: el análisis léxico, el análisis sintáctico y la traducción dirigida dirigida por la sintaxis usando esquemas de traducción. En el análisis léxico se especifican los tokens, los cuales se van a encargar de analizar si un símbolo símbolo pertenece pertenece o no al lenguaje, nos ayudaremos ayudaremos de la herramienta Flex. Flex. En el análisis análisis sintáctico vamos vamos a especificar especificar la gramática libre del contexto para nuestro lenguaje, nos apoyaremos de la herramienta Bison, adicionando código de C para algunas funciones requeridas y se encargara de ver la estructura de las sentencias y los tokens . La traducción dirigida por la sintaxis usando esquemas de traducción va adherida al análisis sintáctico, específicamente en las declaraciones de gramática y contienen reglas semánticas, estas reglas suelen tener código de C indicando las operaciones a realizar. Para terminar el desarrollo vamos a realizar un entorno web el cual estará en un servidor web y con el cual podremos ingresar el código a compilar. Este entorno web se encargara de hacer consultas al compilador y obtendrá los resultados para ser mostrados.
Abstract
This report is focused on the design and implementation of an online compiler in order to be able to perform calculations and test algorithms desktop using a simple programming language. To develop it is necessary to use Flex and Bison tools which are responsible for generating code for lexical and syntactic analyzers respectively. For the design and implementation has to have the following structure which includes: lexical analysis, analysis, parsing and translation using syntax-directed translation schemes. In the lexical analysis tokens, which will be in charge of analyzing whether or not a symbol belongs to language, we will help the Flex tool specified. In parsing we will specify the context-free grammar for our language, we will rely on the Bison tool, adding C code required for some functions and be responsible to see the structure of sentences and tokens. The syntax-directed translation using translation schemes will parse adhered to, specifically statements contain grammar and semantic rules, these rules often have C code indicating the operations to perform. To complete the development we will make a web environment which will be on a web server and which we can enter the code to compile. This web environment would be responsible responsible for querying the compiler and get the results to be displayed.
Key words: Flex, Bison, Parsers, Scanners, Schema of translation, compiler online.
Tabla de Contenidos RESUMEN ...................................... .......................................................... ........................................ ......................................... ........................................ ....................................... ........................... .......2 ABSTRACT ..................................... ......................................................... ........................................ ........................................ ........................................ ........................................ ........................... .......3 ............................................................ ........................................ ........................................ ........................................ ........................... .......6 LISTA DE TABLAS ........................................ ......................................................... ........................................ ......................................... ................................. .............7 LISTA DE ILUSTRACIONES ...................................... ......................................................... ....................................... ......................................... ........................................ ................................. ..............8 INTRODUCCIÓN ...................................... .......................................................... ........................................ ....................9 CAPÍTULO 1: DESCRIPCIÓN DEL PROYECTO...................................... 1.1.
PROBLEMA ....................................... .......................................................... ........................................ ......................................... ........................................ .............................. ..........9
1.2.
PLANTEAMIENTO DE LA SOLUCIÓN ....................................... .......................................................... ........................................ ......................................... ....................9
1.3.
OBJETIVOS DEL PROYECTO ....................................... ........................................................... ........................................ ........................................ .............................. ..........9
1.3.1.
Objetivo General ...................................... .......................................................... ........................................ ........................................ .............................. ..........9
1.3.2.
Objetivos Específicos
....................................... .......................................................... ........................................ ......................................... ....................... ... 9
........................................................... ........................................ ......................................... ...................... 10 CAPÍTULO 2: MARCO TEÓRICO........................................ 2.1.
INTRODUCCIÓN A LOS COMPILADORES ....................................... ........................................................... ........................................ ................................ ............10
2.1.1.
Definición de un compilador ..................................... ......................................................... ........................................ ................................ ............10
2.1.2.
Estructura de un Compilador ........................................ ........................................................... ....................................... ............................. .........11
2.2.
ANÁLISIS LÉXICO ...................................... .......................................................... ........................................ ........................................ ........................................ ...................... .. 12
2.3.
ANÁLISIS SINTÁCTICO
2.3.1.
2.4.
...................................... .......................................................... ........................................ ......................................... ................................... ..............14
Análisis sintáctico sintáctico descendente ........................................ ........................................................... ....................................... ......................... ..... 15
ANÁLISIS SEMÁNTICO ...................................... .......................................................... ........................................ ......................................... ................................... ..............16
2.4.1.
Traducción dirigida por la sintaxis ....................................... .......................................................... ........................................ ....................... 17
2.4.2.
Atributos..................................... ......................................................... ........................................ ......................................... ......................................... ...................... 18
2.4.3.
Notaciones para asociar reglas semánticas ........................................ ............................................................ ......................... .....18
2.4.3.1.
Definición dirigida por la sintaxis
2.4.3.2.
Esquemas de traducción .................................. .................................................... .................................... .................................... .................................... ........................ ...... 19
.................................. .................................................... .................................... .................................... ........................... ......... 18
2.5.
GENERACIÓN DE CÓDIGO INTERMEDIO ..................................... ......................................................... ........................................ ................................... ...............20
2.6.
GENERACIÓN DE CÓDIGO FINAL ........................................ ........................................................... ........................................ ......................................... ...................... 20
2.7.
TABLAS DE SÍMBOLOS Y TIPOS...................................... .......................................................... ........................................ ........................................ ......................... ..... 21
2.8.
MANEJO DE ERRORES
2.9.
HERRAMIENTAS DE CONSTRUCCIÓN DE COMPILADORES ....................................... .......................................................... ............................... ............22
2.10.
HERRAMIENTA PARA GENERAR ANALIZADORES LÉXICOS FLEX ...................................... .......................................................... ......................... ..... 23
2.10.1.
...................................... .......................................................... ........................................ ......................................... ................................... ..............21
ESTRUCTURA DE UN FICHERO FLEX ...................................... .......................................................... ........................................ ................................... ...............24
2.10.1.1.
LA SECCIÓN DE DEFINICIONES
2.10.1.2.
LA SECCIÓN DE REGLAS
........................................ ............................................................ ........................................ ................................... ...............24
...................................... .......................................................... ........................................ ........................................ ......................... ..... 24
2.10.1.3. 2.11.
LA SECCIÓN DE CÓDIGO DE USUARIO ...................................... .......................................................... ........................................ ............................ ........25
HERRAMIENTA PARA GENERAR ANALIZADORES SINTÁCTICOS BISON ........................................ ...................................................... ..............25
2.11.1.
ESTRUCTURA DE BISON ....................................... ........................................................... ........................................ ........................................ ............................ ........25
2.11.1.1.
DECLARACIONES EN C Y EN BISON ..................................... ......................................................... ........................................ ................................ ............25
2.11.1.2.
REGLAS GRAMATICALES Y ACCIONES
2.11.1.3.
CÓDIGO C ADICIONAL ........................................ ............................................................ ........................................ ........................................ ......................... ..... 26
2.12.
...................................... .......................................................... ........................................ ............................ ........26
UN SERVIDOR WEB ...................................... .......................................................... ........................................ ........................................ ...................................... ..................26
........................................................... ........................................ ........................................ ............................ ........27 CAPÍTULO 3: DESARROLLO ....................................... 3.1.
ANÁLISIS LÉXICO ...................................... .......................................................... ........................................ ........................................ ........................................ ...................... .. 27
3.1.1.
Definición de tokens
3.1.2.
Implementación Implementación en FLEX ....................................... ........................................................... ........................................ ................................... ...............27
3.2.
ANÁLISIS SINTÁCTICO
........................................ ........................................................... ........................................ ......................................... ...................... 27
...................................... .......................................................... ........................................ ......................................... ................................... ..............29
3.2.1.
Definición de Gramáticas libres del Contexto ...................................... .......................................................... ......................... ..... 29
3.2.2.
Implementación Implementación en BISON ..................................... ......................................................... ........................................ ................................... ...............29
3.3.
COMPILACIÓN DEL PROGRAMA
3.4.
CREACIÓN DE PROYECTO WEB Y FUNCIONAMIENTO ONLINE ........................................ ............................................................ ......................... ..... 33
........................................ ........................................................... ........................................ ......................................... ...................... 32
3.4.1.
Pasos para crear el proyecto ........................................ ........................................................... ....................................... ............................. .........33
3.4.2.
Explicación del funcionamiento del proyecto ...................................... .......................................................... ......................... .....34
3.4.3.
Controlador de servidor ...................................... ......................................................... ........................................ ....................................... ..................35
3.4.4.
Despliegue de la aplicación hacia servidor (Heroku) ...................................... .................................................... ..............36
............................................................ ........................................ ........................................ ........................................ ............................ ........37 CONCLUSIONES ........................................ ......................................................... ........................................ ......................................... ......................................... ......................38 RECOMENDACIONES ..................................... ............................................................ ........................................ ........................................ ........................................ ...................................... ..................39 GLOSARIO ........................................ ........................................................... ....................................... ......................................... ........................................ ............................... ............40 BIBLIOGRAFÍA ........................................ ......................................................... ........................................ ......................... .....41 ANEXO 1: HERRAMIENTAS NECESARIAS .....................................
Lista De Tablas Tabla 1: Definici Def inición ón de tokens para el analizador sintáctico .......................................... .......................................... 27 Tabla 2: Definici Def inición ón de la gramática libre del d el contexto y reglas semánticas.................. 29
Lista De Ilustraciones Ilustración 1: Esquema de un Traductor. (Galvez Rojas & Mora Mata, 2005).............. 10 Ilustración 2: Esquema de un Compilador (Ruiz Catalan, 2010) .................................. .................................. 10 Ilustración 3: Fases de un compilador: compilador: (Ruiz Catalan, 2010)........................................ ........................................ 12 Ilustración 4: Ejemplo de Árbol sintáctico. (Galvez Rojas & Mora Mata, 2005) ............ 14 Ilustración 5: Árbol sintáctico 1 (Ruiz Catalan, 2010) ........................................... .................................................... ......... 15 Ilustración 6:Árbol sintáctico s intáctico 2 (Ruiz Catalan, 2010) ............................................ ..................................................... ......... 15 Ilustración 7:Análisis sintáctico descendente para id+id*id (Aho, Lam, Sethi, & Ullman, 1998)............................................ ................................................................... ............................................. ............................................ ...................................... ................ 16 Ilustración 8: Traducción dirigida dirigida por la sintaxis. s intaxis. (Galvez Rojas & Mora Mata, 2005) . 18 Ilustración 9: Definición orientada por la sintaxis de una calculadora de escritorio simple. (Aho, Lam, Sethi, & Ullman, 1998) .......................... ................................................ .......................................... .................... 19 Ilustración 10: Implementación de un esquema de traducción orientado. (Aho, Lam, Sethi, & Ullman, 1998)............................... 1998)...................................................... .............................................. ............................................. ........................ 19 Ilustración 11: Codigo HTML de la vista .................................................... ........................................................................ .................... 34 Ilustración 12: Interfaz de Compilador Compilador Online............................................ ................................................................ .................... 35 Ilustración 13: Codigo php para el control del servidor ............................................ ................................................ .... 35
Introducción La teoría de compiladores es un área muy interesante y compleja. El implementar un lenguaje de programación y crear un compilador para este es una tarea muy dura, pero el ámbito de las aplicaciones son muy variadas y la satisfacción es grande. Los compiladores están muy ligados a las teorías de autómatas, lenguajes formales y teoría de la computación. El desarrollo de estos comprende varias partes, el análisis léxico, sintáctico, semántico, la generación de código intermed intermedio io y generación de código final. Por otro lado el avance de la tecnología respecto a software, ha permitido que la web sea muy concurrida y por ende las aplicaciones web han ido en aumento, tal es el caso que para las personas ligadas al ámbito de las ciencias de la computación se nos sea de gran utilidad acceder a un sitio web y poder realizar cálculos y pruebas de escritorio escritorio de nuestros algoritmos.
Capítulo 1: Descripción Del Proyecto 1.1. Problema El avance de la tecnología, tecnología, el uso uso extendido de las aplicaciones aplicaciones web web y la necesidad de tener un medio virtual online para poder realizar cálculos, pruebas de escritorio de algoritmos. .
1.2. Planteamiento de la Solución Por la problemática mostrada anteriormente se propone el diseño e implementación de un compilador online para facilitar el acceso, solo será necesario el uso de aparatos móviles ya que estará disponible en un servidor web.
1.3. Objetivos del Proyecto 1.3.1. Objetivo General Diseño e implementación de un compilador online.
1.3.2. Objetivos Específicos 1. Diseñar un lenguaje de programación sencillo que resuelva operaciones ope raciones e instrucciones básicas. 2. Estudiar la herramienta herramienta Flex Flex para desarrollo desarrollo del Análisis Léxico Léxico 3. Estudiar la la herramienta Bison para el desarrollo desarrollo del Análisis Sintáctico. Sintáctico. 4. Estudiar la la Traducción dirigida dirigida por la sintaxis sintaxis para el Análisis Semántico. Semántico.
Capítulo 2: Marco Teórico 2.1.
Introducción a los Compiladores
2.1.1. Definición de un compilador Los procesadores del lenguaje son aplicaciones las cuales reciben como entrada un lenguaje. Este concepto es abarcado por los traductores, ” Un Un traductor se define como un programa que traduce o convierte desde un texto o programa escrito en un lenguaje fuente hasta un texto o programa equivalente escrito en un lenguaje destino produciendo, si cabe, mensajes de error ” (Galvez Rojas & Mora Mata, 2005). 2005) . Ver figura 1
Ilustración 1: Esquema de un Traductor. (Galvez Rojas & Mora Mata, 2005)
Dentro de los traductores están los compiladores, un compilador es un sistema de software que se encarga de la la traducción de un lenguaje lenguaje de alto nivel a un lenguaje de bajo nivel, ver figura 2 , “un compilador es un programa que puede leer un programa en un lenguaje (el lenguaje fuente) y traducirlo en un programa equivalente equivalente en otro lenguaje lenguaje (el lengua je destino)” . (Aho, Lam, Sethi, & Ullman, 1998). 1998) .
Ilustración 2: Esquema de un Compilador (Ruiz Catalan, 2010)
Otro tipo de traductor son los intérpretes, un intérprete es como un compilador, solo que la salida es una ejecución. El programa de entrada se reconoce y
ejecuta a la vez. No se produce un resultado físico (código máquina) sino sino lógico (una ejecución). Hay lenguajes que sólo pueden ser interpretados, como por ejemplo Lisp. La diferencia entre compilador e intérprete es que el compilador analiza todo el programa fuente, crea el programa objeto y luego permite su ejecución (sólo del programa objeto obtenido) y el intérprete lee sentencia por sentencia el programa fuente, la convierte en código objeto y la ejecuta. Por lo tanto, es fácil comprender que tras compilar un programa, su ejecución es mucho más rápida que la ejecución de un programa interpretado.
2.1.2. Estructura de un Compilador En la estructura de un compilador hay dos procesos en esta asignación: análisis y síntesis. La parte del análisis divide el programa fuente en componentes e impone una estructura gramatical sobre ellas. Después utiliza esta estructura para crear una representación intermedia del programa fuente. Si la parte del análisis detecta que el programa fuente está mal formado en cuanto a la sintaxis, o que no tiene una semántica consistente, entonces debe proporcionar mensajes mensajes informativos para que el usuario us uario pueda corregirlo. La parte del análisis también recolecta información sobre el programa fuente y la almacena en una estructura de datos llamada tabla de símbolos, la cual se pasa junto con la representación intermedia intermedia a la parte de la síntesis. La parte de la síntesis construye el programa destino deseado a partir de la representación intermedia y de la información en la tabla de símbolos. A la parte del análisis se le llama comúnmente el front-end del compilador; la parte de la síntesis (propiamente la traducción) traducción) es el back-end. En la figura 3 podemos ver el esquema de un compilador. compilador.
Ilustración 3: Fases de un compilador: (Ruiz Catalan, 2010)
2.2.
Análisis Léxico En esta fase, la cadena de caracteres que constituye el programa fuente se lee de izquierda a derecha y se agrupa en componentes léxicos, que son secuencias de caracteres que tienen un significado atómico; además el analizador léxico trabaja con la tabla de símbolos introduciendo en ésta los nombres de las variables. Los componentes componentes léxicos se llaman llaman tokens (caracteres (caracteres relacionados relacionados entre sí). Estos tokens constituyen la entrada para el siguiente proceso de análisis (análisis sintáctico). El agrupamiento de caracteres en tokens depende del
lenguaje que vayamos a compilar; es decir, un lenguaje generalmente agrupará caracteres en tokens diferentes de otro lenguaje. Los tokens pueden ser de dos tipos; cadenas específicas como palabras reservadas, puntos y comas, etc., y no específicas, como identificadores, constantes y etiquetas. La diferencia entre ambos tipos de tokens radica en si ya son conocidos previamente o no. Por ejemplo, la palabra reservada while es conocida previamente en un lenguaje que la utilice, pero el nombre de una variable no es conocido anteriormente ya que es el programador el que le da nombre en cada programa. Por lo tanto, y resumiendo, el analizador léxico lee los caracteres que componen el texto del programa fuente y suministra tokens al analizador sintáctico. El analizador léxico irá ignorando las partes no esenciales para la siguiente fase, como pueden ser los espacios en blanco, los comentarios, etc., es decir, realiza la función de preprocesador preprocesador en cierta c ierta medida. Los tokens se consideran entidades con dos partes: su tipo y su valor o lexema. En algunos casos, no hay tipo (como en las palabras reservadas). Esto quiere decir que por ejemplo, si tenemos una variable con nombre “x”, su tipo
es identificador y su lexema es x. Por ejemplo, supongamos que tenemos que analizar un trozo de programa fuente escrito en lenguaje Java: x Java: x = x + y – 3; Los tokens suministrados al analizador sintáctico serían estos (el nombre que le demos a los tipos de tokens depende de nosotros):
“x” : Tipo identificador, lexema x
“=” : Lexema =
“x” : Tipo identificador, lexema x
“+” : Lexema +
“y” : Tipo identificador, lexema y
“-“ : Lexema –
“3” : Tipo entero, lexema 3
“;” : Lexema ;
2.3.
Análisis Sintáctico El análisis sintáctico trabaja con una gramática libre libre del contexto y genera el árbol sintáctico que reconoce su sentencia de entrada. En nuestro caso las categorías gramaticales gramaticales del análisis léxico son los terminales terminales de la gramática. Ejemplo de Gramática libre del contexto. S ->
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 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 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 para asociar reglas reglas semánticas 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 representación intermedia puede tener diversas formas. En el presente ejemplo se trabajará con una forma intermedia llamad a “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 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, 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. intermedio.
2.7.
Tablas de Símbolos y tipos Ponemos aquí esta sección, aunque no es una fase del proceso de compilación, 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, procedimientos, sus nombres, sus parámetros y en generar cuanta información vaya a ser necesaria 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 acceso a estas tablas a lo largo de todo el proceso de compilación. Además, el número de accesos 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 t iempo 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). 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 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 f ase 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 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 cualquier desarrollador desarrollador de software, el desarrollador desarrollador de compiladores puede utilizar para su beneficio los entornos de desarrollo de software modernos que contienen herramientas como editores de lenguaje, depuradores, administradores 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 especializadas para ayudar a implementar las diversas fases de un compilador. compilador. Estas herramientas utilizan lenguajes especializados para especificar e implementar componentes específicos, y muchas utilizan algoritmos bastante sofisticados. Las herramientas 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 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. 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 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 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 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. correspondiente.
2.10.1. Estructura de un fichero fichero Flex El fichero de entrada de Flex está compuesto de tres secciones, separadas separadas por una línea donde aparece únicamente un ‘%%’ en esta:
definiciones %% reglas %% código de usuario 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 usuario 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 generado por esa gramática.
2.11.1.
Estructura de Bison La forma general de una gramática de Bison es la siguiente: %{ declaraciones declaraciones en C y en Bison %} Reglas gramaticales 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. s intá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 tokens Tabla 1: Definición de tokens para el analizador sintác tico
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 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 #define YY_DECL int yylex() #include "calc.tab.h" %} Definición de Reglas Aquí se definirán los los patrones y tokens respectivos respectivos guiándonos de la 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 {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;} 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 Gramáticas libres del Contexto Contexto Las gramáticas a usar serán las siguientes. Tabla 2: Definición de la gramática libre del c ontexto y reglas semánticas Reglas Semánticas
Producciones → Ԑ | → T_NEWLINEA | .T_NEWLINEA .T_NEWLINEA | T_NEWLINEA | T_QUIT T_NEWLINEA
{ printf("%f\n", e xpr_mixta.valor);} xpr_mixta.valor);} { printf("%i\n", expr.valor); } {printf("bye!\n"); {printf("bye!\n"); e xit(0); }
. → T_FLOAT | .T_MAS .T_MAS . |.T_MENOS |.T_MENOS . . | T_POR | T_DIVIDE |T_PARENT_IZQ |T_PARENT_IZQ T_PARENT_DER | T_MAS | T_MENOS | T_POR | T_DIVIDE | T_MAS | T_MENOS | T_POR T_POR | T_DIVIDE | T_DIVIDE
{ .valor = T_float.Valor; } { .valor = .valor + .valor} { .valor = .valor - .valor} xpr_mixta>.valor} { .valor = .valor .valor * .valor} .valor} { .valor = .valor / .valor} { .valor = (.valor)} (.valor)} { .valor .valor = + } { .valor .valor = - } { .valor .valor = * } { .valor .valor = / } { .valor .valor = + } { .valor .valor = - } { .valor .valor = * } { .valor .valor = / } { .valor .valor = / (float)}
→ T_INT
{.valor {.valor = T_INT.valor; T_INT.valor; } {.valor {.valor = .valor + .valor } {.valor {.valor = .valor - .valor} {.valor {.valor = .valor* .valor} {.valor {.valor =.valor}
| T_MAS | T_MENOS | T_POR |T_PARENT_IZQ |T_PARENT_IZQ T_PARENT_DER
3.2.2. Implementación en BISON Para la implementación del analizador sintáctico debemos tener instalado BISON, luego v amos 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, 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 #include extern int yylex(); extern int yyparse(); extern FILE* yyin; void yyerror(const char* s); %} Declaraciones en Bison Seguidamente vamos a declarar declarar todos los tokens que que declaramos 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 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 gramáticas libres 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 Adicionalmente usaremos la traducción dirigida 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: expresion_mixta: T_FLOAT
{ $$ = $1; }
| expresion_mixta expresion_mixta T_MAS expresion_mixta expresion_mixta
{ $$ = $1 + $3; }
| expresion_mixta expresion_mixta T_MENOS expresion_mixta expresion_mixta
{ $$ = $1 - $3; }
| expresion_mixta T_POR expresion_mixta expresion_mixta { $$ = $1 * $3; } | expresion_mixta expresion_mixta T_DIVIDE expresion_mixta expresion_mixta
{ $$ = $1 / $3; }
| T_PARENT_IZQ expresion_mixta expresion_mixta T_PARENT_DER
{ $$ =
$2; }
;
| expresion T_MAS expresion_mixta expresion_mixta
{ $$ = $1 + $3; }
| expresion T_MENOS expresion_mixta expresion_mixta
{ $$ = $1 - $3; }
| expresion T_POR expresion_mixta expresion_mixta
{ $$ = $1 * $3; }
| expresion T_DIVIDE expresion_mixta expresion_mixta
{ $$ = $1 / $3; }
| expresion_mixta expresion_mixta T_MAS expresion
{ $$ = $1 + $3; }
| expresion_mixta expresion_mixta T_MENOS expresion
{ $$ = $1 - $3; }
| expresion_mixta expresion_mixta T_POR expresion
{ $$ = $1 * $3; }
| expresion_mixta 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 expresion T_MENOS expresion { $$ = $1 - $3; } | expresion T_POR expresion
{ $$ = $1 * $3; }
| T_PARENT_IZQ expresion expresion T_PARENT_DER 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 Adicionalmente se implementa la función yyerror declarada al inicio inicio del archivo. %% int main(int argc, char *argv[]) { if ((yyin = fopen(argv[1], "rt")) == NULL) NULL) /*yyin:variable /*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 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 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: Git: Sistema de control de versiones, nos servirá para poder hacer un despliegue a nuestra servidor.
Heoku Toolbet: 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 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 - prefer–
dist 5.1
2. Realizar el primer commit commit del proyecto con los los siguientes comandos comandos
git add
git commit
A
–
–
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 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 proporciona el framework así mismo como el guardado. $code = $request $request->get( ->get('code'); $filename = str_random(16 str_random(16); ); Storage::disk('local' )->put($filename )->put($filename, , $code $code); );
Ejecutamos la función de php exec, pasando el comando que no hará la compilación compilación de nuestro archive fuente. $cmd = "./../storage/compiler/ejecutable ../storage/app/" . $filename $filename; ; $cmd, , exec($cmd
$out); $out );
La variable $out será la que contendrá la salida de la compilación y ejecución, esto será lo que devolveremos devolveremos en formato JSON J SON hacia el cliente. 3.4.4.
Despliegue de la aplicación hacia servidor (Heroku)
Antes de ejecutar los comandos proporcionados proporcionados en necesario tener una cuenta en esta plataforma.
Creación de la la aplicación aplicación Heroku despliegue, despliegue, mediante la la línea de comandos ejecutamos lo siguiente
heroku login
heroku créate livecompiler
git push heroku master
Configuración Configuración de clave de aplicación 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 consu ltas mediante una interfaz web y está disponible para cualquier aparato electrónico que pueda conectarse a internet.
-
Se logró logró establecer establecer un un lenguaje lenguaje de programación programación que usa usa operaciones operaciones básicas.
-
Se logró generar el analizador léxico a partir de Flex.
-
Se logró logró generar el analizador sintáctico y semántico a partir partir de Bison. Bison.
-
Se estudió estudió y puso en práctica práctica la 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 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: Programación: según según DRAE. Conjunto de signos y reglas que permite la comunicación con un ordenador. Alfabeto: Conjunto Alfabeto: Conjunto no vacío de símbolos Cadena: Cadena: secuencias de caracteres formados a partir de símbolos. Gramática: Gramática: mecanismo que nos permite generar un lenguaje. Derivación: Derivación: proceso que consiste en sustituir el lado izquierdo por su lado derecho Sentencia: Sentencia: cadena generada a partir de una gramática. Sintaxis: Sintaxis: la forma o estructura de las expresiones, declaraciones y unidades de programa. Semántica: Semántica: el significado de las expresiones, declaraciones, y unidades de programas. Notación BNF. 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: Compiladores: Principios, Tecnicas y Herramientas 2 Edicion. New Edicion. New Jersey: Pearson. Bejar Hernandez, R. (20 de 07 de 2016). Universidad Universidad de ZaragozaZaragoza- Introduccion a Flex y Bison. Obtenido Bison. Obtenido de http://webdiis.unizar.es/asi http://webdiis.unizar.es/asignaturas/LGA/materi gnaturas/LGA/material_2004_200 al_2004_2005/Intro_Flex_Bi 5/Intro_Flex_Bison. son. pdf Galvez Rojas, S., & Mora Mata, M. A. (2005). TRADUCTORES Y COMPILADORES CON LEX/YACC, JFLEX/CUP Y JAVACC. Malaga: JAVACC. Malaga: Universidad de Malaga. Ruiz Catalan, J. (2010). Compiladores: Teoria e Implementacion. Implementacion. Madrid: Graficas DEVA S.L.
Anexo 1: Herramientas necesarias Puedes descargar las herramientas herramientas Flex y Bison B ison en la siguiente dirección:
Flex: -
Ingresar al siguiente link: http://gnuwin32.sourceforge.n http://gnuwi n32.sourceforge.net/packages/ et/packages/flex.htm flex.htm
-
Descargar la última versión
Bison: -
Ingresar al siguiente link: http://gnuwin32.sourceforge.net/ http://gnuwi n32.sourceforge.net/packages/bi packages/bison.htm son.htm
-
Descargar la ultima version
MinGW: -
MinGw es un compilador del lenguaje C/C++, trae librerías necesarias para la la ejecución de programas en C/C++
-
Ingresar en el siguiente link
-
http://www.mingw.org/category/wi http://www.mingw .org/category/wiki/download ki/download
-
Descargar la versión para tu tipo tipo de arquitectura x86 o x64
