UNIVERSIDAD DON BOSCO FACULTAD DE INGENIERIA TRABAJO DE GRADUACION PARA OPTAR AL GRADO DE INGENIERO EN CIENCIAS DE LA COMPUTACION DESARROLLO DE UN EDITOR E INTERPRETE DE DIAGRAMAS DE FLUJO DE DATOS CON GENERACION DE CODIGO EN C++ Y JAVA PRESENTADO POR: OSCAR DOUGLAS BONILLA CASTRO FERNANDO ENRIQUE CASTRO MORALES ASESOR: ING. JAIME ANAYA SEPTIEMBRE DE 2007 SOYAPANGO – SAN SALVADOR - EL SALVADOR 1 UNIVERSIDAD DON BOSCO FACULTAD DE INGENIERIA AUTORIDADES ING. MIGUEL FEDERICO HUGUET RIVERA RECTOR PBRO. VICTOR BERMUDEZ YANEZ VICERRECTOR ACADEMICO LIC. MARIO OLMOS ARGUETA SECRETARIO GENERAL ING. ERNESTO GODOFREDO GIRON DECANO FACULTAD DE INGENIERIA 2 UNIVERSIDAD DON BOSCO FACULTAD DE INGENIERIA TRABAJO DE GRADUACION PARA OPTAR AL GRADO DE INGENIERO EN CIENCIAS DE LA COMPUTACION DESARROLLO DE UN EDITOR E INTERPRETE DE DIAGRAMAS DE FLUJO DE DATOS CON GENERACION DE CODIGO EN C++ Y JAVA TRIBUNAL EXAMINADOR ING. RENE TEJADA ING. MELVYN GOMEZ DR. JORGE LEMUS JURADO EVALUADOR JURADO EVALUADOR JURADO EVALUADOR ING. JAIME ANAYA ING. CARLOS TEJADA ASESOR TUTOR 3 AGRADECIMIENTOS (Oscar Bonilla) Es inevitable dedicar esta tesis a Dios y a todos los seres queridos que me rodean. Primero a Dios porque fue él quien puso todas esas herramientas en mi camino para que yo lograra todas las metas que me he propuesto a lo largo de mi vida cotidiana, y de mi vida Universitaria. A mis padres Nelson Bonilla y Gloria Castro de Bonilla por haberme inculcado el valor de no desanimarme jamás por los obstáculos que encontrase en mi vida, fueron ellos los que primero me enseñaron a encontrar una solución a todos los problemas que se presentaran ante mí. Me enseñaron a mirar mas allá de los problemas de solo lo que se muestra ligeramente sino a analizar toda la situación como una sola sobre los sucesos que podrían pasar al tomar una decisión. A mis hermanos Nelson y Salvador por haber estado ahí cada vez que necesite un consuelo, alguien con quien hablar, con quien reír o con quien apoyarme cuando no encontraba la solución de algo. A mi novia Korina por estar ahí para apoyarme, y no dejar que me desanimara nunca, a tener entusiasmo y coraje para poder salir adelante. A los Scouts por mostrarme el camino de una disciplina sana y vocación a ayudar a los demás sin esperar nada a cambio. A mis profesores a lo largo de mi vida como estudiante que me han ido mostrando un camino lleno de cosas nuevas que aprender. A mi compañero de tesis por no desanimarse y trabajar a mi lado para que los objetivos se lograran; a nuestro asesor el Ing. Jaime Anaya y nuestro tutor el Ing. Carlos Tejada por guiarnos sobre este camino culminante del trabajo de graduación. Agradezco también a mis amigos y compañeros de universidad que estuvieron ahí para apoyarme y hacer que se sintiera menos la presión de estudiar a Walter, Rigoberto, Josué, José Luís, Angel, Ricardo a todos ellos gracias. 4 AGRADECIMIENTOS (Fernando Castro) A Dios por haberme dado la oportunidad de existir en este tiempo y en este espacio. A mi madre María, que siempre ha sido un modelo a seguir, siempre estuvo ahí cuando necesite apoyo y sin su esfuerzo no hubiera sido posible la culminación de mi carrera. A mi abuela Maria Brígida, que ha sido el segundo pilar en mi vida y siempre me ha apoyado en todo. A mi asesor Ing. Anaya y a mi tutor Ing. Tejada, sin su apoyo no habría sido posible la realización de este trabajo de graduación. A mi compañero de tesis Oscar, sin su apoyo no habría sido posible la culminación de este proyecto. A mis amigos, que siempre a lo largo de toda mi carrera me brindaron sus conocimientos y su apoyo incondicional. 5 INDICE Introducción............................................................................................................13 1 Antecedentes e importancia................................................................................14 1.1 Antecedentes ……...…...…..............................................................................15 1.2 Importancia de la investigación……………………………………………………16 1.3 Planteamiento del problema............………………………………………………17 1.3.1 Definición del tema.............................................................................17 1.4 Justificación……………………………………………………………...................17 1.5 Objetivos……………………………………………………………………………..18 1.5.1 Objetivo General………………………………………………………….18 1.5.2 Objetivo Especifico……………………………………………………….18 1.6 Alcances……………………………………………………………………………..19 1.7 Delimitación……...………………………………………………………………….19 1.8 Proyección social…………………………………………………………..……….20 1.9. Metodología de la investigación………………………………………………….20 1.9.1 Investigación bibliográfica………………………………………………..21 1.9.2 Asesoría profesional...........................................................................21 1.9.3 Información disponible en Internet .....................................................21 1.9.4 Estudio técnico de aplicaciones existentes…………………………….21 1.9.4.1 DFD. .....................................................................................21 1.9.4.2 Autoflowchart 1.0..................................................................22 1.9.4.3 Smartdraw. ...........................................................................23 2. Marco teórico………………………………………………………………………….25 2.1 Referencias históricas......................................................................................26 2.2 Marco conceptual. ...........................................................................................27 2.2.1 Computadoras y software. .................................................................27 2.2.2 Software de base y de aplicación. ....................................................28 2.2.3 Traductores: intérpretes y compiladores............................................28 2.3 Fundamentos de intérpretes. ..........................................................................29 2.3.1 Interprete. ..........................................................................................29 2.3.2 Estructura de un intérprete. ...............................................................29 2.3.3 Ventajas de la utilización de intérpretes. ...........................................32 6 2.3.4 Ventajas de interpretar frente a compilar………………………………33 2.3.5 Aplicaciones de sistemas basados en intérpretes..............................33 2.3.6 Tipos de intérpretes. .........................................................................34 2.4 Compiladores. .................................................................................................37 2.4.1 Historia de los compiladores…………………………………………….38 2.4.2 Partes de un compilador. ...................................................................39 2.4.3 Tipos de compiladores. .....................................................................39 2.4.4 Fases de la compilación. ...................................................................40 2.4.5 Forma de examinar de un compilador. ..............................................41 2.4.6 Análisis de un código fuente. .............................................................41 2.4.7 Ventajas de compilar frente a interpretar………………………………42 2.5 Compiladores e intérpretes en general............................................................42 2.5.1 Diferencias entre compiladores e interpretes.....................................42 2.5.2 Ventajas y desventajas de los compiladores e intérpretes.................43 2.6 Algoritmos. ......................................................................................................44 2.6.1 Características de los algoritmos……………………………………….45 2.7 Diagramas de flujo de datos (dfd)....................................................................47 2.7.1 Reglas para la creación de diagramas...............................................50 2.7.2 Nacimiento de los diagramas de flujos...............................................51 2.7.3 Características de los diagramas estructurados................................52 2.7.4 Principales estructuras de los diagramas de flujo estructurados.......52 3. Herramientas a utilizar......................................................................................55 3.1 Visual c++ 6.0 profesional................................................................................56 3.1.1 Requerimientos de recursos...............................................................57 3.2 Qt designer.......................................................................................................58 3.3 Modulo qcanvas...............................................................................................60 4 Aplicación............................................................................................................62 4.1 Requerimientos del sistema.............................................................................63 4.1.1 Requerimientos para la ejecución del sistema...................................63 4.1.2 Requerimientos del usuario................................................................64 4.2 Análisis.............................................................................................................64 4.2.1 Tipo de intérprete…………………………………………………………65 4.2.2 Proceso de interpretación...................................................................65 4.2.2.1 Descripción general…………………………………………….65 7 4.2.2.2 Tabla de símbolos………………………………………………66 4.2.2.3 Análisis léxico…………………………………………………...66 4.2.2.4 Análisis sintáctico……………………………………………….66 4.2.2.5 Análisis semantico……………………………………………...67 4.2.2.6 Manejo de errores………………………………………………67 4.2.3 Funciones y operadores soportados por la aplicación.................................67 4.3 Diseño de la aplicación....................................................................................69 4.3.1 Módulos a utilizar................................................................................70 4.3.1.1 Módulo de manejo grafico.....................................................70 4.3.1.2 Módulo de análisis................................................................70 4.3.1.3 Módulo de ejecución.............................................................70 4.3.1.4 Módulo de generación de código..........................................70 4.3.4.5 Módulo de subprograma.......................................................71 4.3.2 Clases a utilizar…………………………………………………………...71 4.3.2.1 Clase elemento…………………………………………...........71 4.3.2.2 Clase EditorFigura………………………..…………………….72 4.3.2.3 Clase Main……………………………………..………………..73 4.3.2.4 Clase variable…………………………………………………...75 4.3.2.5 Clase c_token…………………………………………………...76 4.3.2.6 Clase análisis……………………………………………………76 4.3.2.7 Clases de objeto………………………………………………..77 4.3.3 Estructuras de Datos a utilizar………………………………………......79 4.3.3.1 Listas Enlazadas……………………………………………......79 4.3.3.2 Pilas………………………………………………………………79 4.4 Implementación................................................................................................80 4.4.1 Descripción de la aplicación...............................................................80 4.4.1.1 Creación del diagrama..........................................................80 4.4.1.2 Ejecución del diagrama.........................................................80 4.4.1.3 Generación de código...........................................................81 4.4.2 Funcionamiento del sistema...............................................................81 4.4.2.1 Diagrama de inserción de un nuevo objeto.........................81 4.4.2.2 Diagrama de modificación de un objeto................................82 4.4.2.3 Diagrama de eliminación de objetos.....................................82 4.4.2.4 Diagrama de ejecución de un diagrama...............................83 8 4.4.3 Formularios.........................................................................................84 4.4.3.1 Pantalla principal de la aplicación.........................................84 4.4.3.2 Formulario de inserción de procesos....................................88 4.4.3.3 Formulario de petición de datos........................................... 91 4.4.3.4 Formulario de muestra de datos.......................................... 92 4.4.3.5 Formulario para ciclo while.................................................. 93 4.4.3.6 Formulario para ciclo for...................................................... 94 4.4.3.7 Formulario para decisión if....................................................96 Conclusiones………………………………………………………………………........98 Recomendaciones………………………………………………………………….......99 Bibliografía………….............................................................................................100 Glosario………………….......…….……………………………..………………….....101 Anexos.................................................................................................................104 Normas ISO 9000……………………………………………………………...104 Pasos a seguir para el registro y aprobación de patentes………………...104 Registro de la aplicación para derechos de autor………………………….111 Manual de usuario DFD_GC………………………………………………….112 Tabla comparativa entre DFD_GC y DFD…………………………………..130 9 Índice de Figuras. Figura 1. Pantalla principal del Dfd®......................................................................22 Figura 2. Pantalla principal de Auto FlowChart 1.0................................................22 Figura 3. Pantalla principal de SmartDraw.............................................................24 Figura 4. Esquema general de un intérprete. ........................................................29 Figura 5. Esquema general de un compilador......................................................29 Figura 6. Organización interna de un intérprete.....................................................30 Figura 7. Esquema de un intérprete puro.............................................................35 Figura 8. Esquema del proceso de compilación. ..................................................37 Figura 9. Esquema de la función de un compilador. .............................................38 Figura 10. Pasos para la resolución de un problema.............................................45 Figura 11. Ejemplo de un Diagrama de Flujo de Datos.........................................48 Figura 12. Ejemplo de diagrama de flujo. .............................................................49 Figura 13. Estructura Secuencial...........................................................................53 Figura 14. Estructura Alternativa............................................................................53 Figura 15. Estructura FOR.....................................................................................53 Figura 16. Estructura While....................................................................................54 Figura 17. Estructura Until.....................................................................................54 Figura 18. Entorno de trabajo en Visual C++ 6.0 Profesional................................56 Figura 19. Ejecución de código fuente en C++ 6.0 Profesional.............................57 Figura 20. Barra de herramienta de integración con QT........................................58 Figura 21. Entorno de trabajo del QT Designer 4.2.2............................................59 Figura 22. Ejemplos de figuras con canvas..........................................................60 Figura 23. Diagrama de Inserción de Objetos. .....................................................81 Figura 25. Diagrama de Modificación de Objetos..................................................82 Figura 26. Diagrama de Eliminación de Objetos....................................................82 10 Figura 27. Diagrama de Ejecución de Diagramas.................................................83 Figura 28. Menú Archivo........................................................................................84 Figura 29. Menú Edición........................................................................................85 Figura 30. Menú Insertar........................................................................................85 Figura 31. Menú Ejecución....................................................................................86 Figura 32. Menú Depuración..................................................................................86 Figura 33. Menú Generar…………………………………………...………………….87 Figura 34. Menú Ayuda…………………………………………………………………87 Figura 35. Menú Opciones.....................................................................................87 Figura 36. Pantalla principal de la aplicación. .......................................................88 Figura 37. Formulario de inserción de Procesos…………………………………….88 Figura 38. Tipo y nombre de variable....................................................................89 Figura 39. Tipo de variable....................................................................................89 Figura 40. Lista de variables..................................................................................89 Figura 41.Botones de opciones.............................................................................90 Figura 42. Formulario de Inserción de Procesos...................................................90 Figura 43. Creación de sentencias........................................................................90 Figura 44. Botones de Comando Formulario Proceso...........................................91 Figura 45. Formulario de Petición de Datos...........................................................91 Figura 46. Variables existentes formulario petición de datos.................................91 Figura 47. Lista de variables a pedir al usuario formulario petición de datos........92 Figura 48. Botones de opciones formulario petición de datos...............................92 Figura 49. Botones de comando formulario petición de datos...............................92 Figura 50. Formulario de muestra de datos...........................................................93 Figura 51. Formulario para ciclo While. ................................................................93 Figura 52. Selección de variable ciclo While..........................................................93 11 Figura 53. Condición ciclo While............................................................................94 Figura 54. Valor de paro ciclo While......................................................................94 Figura 55. Botones de comando formulario ciclo While.........................................94 Figura 56. Formulario para ciclo For......................................................................95 Figura 57. Inicialización ciclo For...........................................................................95 Figura 58. Condición de Iteración ciclo For............................................................95 Figura 59. Valor incremento ciclo For....................................................................96 Figura 60. Botones de Comando formulario ciclo For............................................96 Figura 61. Formulario para decisiones IF..............................................................96 Figura 62. Creación de condición If.......................................................................96 Figura 63. Botones de comando formulario sentencia If........................................79 Índice de tablas. Tabla 1.Simbología de diagrama de flujo de datos................................................47 Tabla 2.Conectores de diagramas de flujo de datos..............................................48 Tabla 3.Tabla de símbolos.....................................................................................66 Tabla 4. Tabla de variables de la Clase elemento…………………………………..71 Tabla 5. Métodos de la Clase elemento……………………………………………...71 Tabla 6. Métodos de la Clase EditorFigura………………………………….............72 Tabla 7. Tabla de variables de la Clase Main………………………………..….......73 Tabla 8. Métodos de la Clase Main………………………………………..……….....73 Tabla 9. Tabla de Public Slots de la Clase Main…………………………………….74 Tabla 10. Variables de la Clase variable……………………………………………..75 Tabla 11. Métodos de la Clase variable………………………………………………75 Tabla 12. Tabla de variables de la Clase c_token…………………….…………….76 Tabla 13. Métodos de la Clase c_token………………………………...……………76 Tabla 14. Tabla de variables de la Clase análisis……………………..…………….77 Tabla 15. Métodos de la Clase análisis………………………………………………77 Tabla 16. Tabla de Clases heredadas para la creación de objetos……………….78 12 INTRODUCCIÓN. Actualmente el uso de la informática no se limita a crear aplicaciones comerciales enfocadas a realizar tareas complejas que faciliten el desarrollo de una tarea en empresas. Sino que se está volviendo una necesidad la creación de software educativo y de alto nivel que pueda facilitar la capacitación de los nuevos programadores y así puedan posteriormente enfocarse en desarrollar aplicaciones más complejas. Por lo que para analizar y resolver cualquier tipo de problema es necesario seguir una serie de pasos, es decir, es necesaria la implementación de un algoritmo por medio del cual se pueda resolver dicho problema. Uno de los conceptos más aceptados de algoritmo dice: "es un procedimiento para la resolución de problemas de cualquier tipo por medio de una determinada secuencia de pasos simples y no ambiguos”. La manera más fácil de representar un algoritmo es por medio de un diagrama de flujo de datos. El presente proyecto consiste en el desarrollo de un editor e interprete de diagramas de flujo de datos con generación de código en C++ y Java. Con el desarrollo de esta aplicación se pretende beneficiar a los nuevos programadores brindándoles una herramienta que les permita asimilar los conocimientos básicos de la informática de una manera práctica y además se vayan familiarizando con los lenguajes de alto nivel. En el presente documento se muestran los antecedentes y la importancia por la cual este proyecto se ha realizado, también se da un breve marco teórico que sirva como introducción a la aplicación. Así como también todo lo relacionado a la planificación para el desarrollo de este proyecto como lo son alcances y objetivos que sirvan para dimensionar la aplicación. 13 CAPITULO I ANTECEDENTES E IMPORTANCIA 14 1.1 ANTECEDENTES. La introducción de la informática como un apoyo al proceso de aprendizaje y asimilación de conceptos básicos en entidades educativas ha resultado en la demanda creciente de software educativo. Por lo que es necesario brindar una mejor capacitación a los nuevos programadores por medio de herramientas que les permitan asimilar de una manera más practicas los conceptos básicos de la informática. La investigación se enfoca en desarrollar una aplicación que permita al usuario generar un diagrama de flujo de datos de manera fácil y además brinde herramientas que permitan interactuar con dicho diagrama para comprender de una manera práctica el funcionamiento del mismo. También se podrá generar el respectivo código en C++ y Java del diagrama creado, este es un aspecto que hace que esta aplicación sea única en el mercado, ya que no existe ninguna herramienta que permita la generación de código en lenguaje de alto nivel a partir de un diagrama de flujo de datos. La única aplicación enfocada al desarrollo de diagramas de flujos de datos es el Dfd® que es un editor e intérprete de diagramas de flujo. Con la cual la Universidad del Magdalena obtuvo el primer puesto con el trabajo de investigación y desarrollo "Editor e Intérprete de Algoritmos Representados en Diagramas de Flujo" en el Segundo Evento de Investigación y Divulgación Tecnológica en el Área de Sistemas y Computación, realizado a nivel nacional por la Universidad Cooperativa de Colombia (Santa Marta, octubre de 1997). También obtuvo el primer puesto con el trabajo de investigación y desarrollo "Editor e Intérprete de Algoritmos Representados en Diagramas de Flujo" en el IV Premio Colombiano de Informática Educativa, realizado en Manizales por RIBIE-COL y el Ministerio de Educación Nacional en abril de 1998. El proyecto fue publicado en la revista RIE (Revista de Informática Educativa) de la Universidad de los Andes en el volumen 11 Nº 1. 15 El proyecto se presentó en el IV congreso Iberoamericano de informática educativa RIBIE '98, con una ponencia ante la comunidad de habla hispana y portuguesa en el marco del congreso del 20 al 23 de octubre de 1998 en BRASILIA - BRASIL. Aunque está herramienta tiene sus facilidades también presenta ciertos errores de diseño y de consumo de hardware, además no permite la generación de código en lenguaje de alto nivel. Lo que se pretende con la aplicación es potenciar la capacidad de los nuevos programadores brindándoles una herramienta que les permita interactuar con los algoritmos de manera práctica y que además puedan desde un principio generar software. 1.2 IMPORTANCIA DE LA INVESTIGACIÓN. Actualmente no es posible encontrar una aplicación que permita a los nuevos programadores diseñar algoritmos por medio de diagramas de flujo y generar su respectivo código funcional. En las instituciones educativas se enseña de manera teórica el manejo de algoritmos y se enseña posteriormente la generación de código en un lenguaje de alto nivel. No existen laboratorios de algoritmos, ni mucho menos aplicaciones que permitan poner en práctica los nuevos conocimientos sobre algoritmos. El diseño de software utilizando diagramas de flujo es una de las herramientas básicas de la informática ya que con esto se incrementa la capacidad de análisis y se va forjando en los nuevos programadores una disciplina de ingeniería de software ya que actualmente cuando es necesario diseñar una aplicación lo primero que se hace es comenzar a programar sin haber hecho antes una diseño completo de la aplicación deseada lo que deriva en gasto innecesario de tiempo y recursos. 16 1.3 PLANTEAMIENTO DEL PROBLEMA. ¿Existe actualmente en el mercado o en las instituciones educativas una herramienta informática que facilite la adquisición de conocimientos sobre algoritmos de manera práctica y que además tenga la facilidad de generar código en lenguajes de alto nivel como lo son C++ y Java? Por el momento no ha sido posible encontrar una herramienta de este tipo que sea fácil de utilizar y le permita al alumno experimentar de una manera práctica el manejo de algoritmos y a la vez permita familiarizarse con los lenguajes de alto nivel. 1.3.1 DEFINICIÓN DEL TEMA. Desarrollo de un Editor e Intérprete de Diagrama de Flujo de Datos con generación de código en C++ y Java para la enseñanza y Aprendizaje de la Programación Estructurada. El objetivo es desarrollar una herramienta que permita al alumno crear diagramas de flujo de datos y estos puedan ser analizados por medio de herramientas de ejecución como “Ejecución Paso a Paso” y una ventana de depuración que muestre como cambian los valores de las expresiones a medida que un algoritmo se ejecuta. Se tendrán también las opciones de generar el código en Java o C++ del diagrama de flujo que se ha creado. 1.4 JUSTIFICACIÓN. La base de la programación en computadoras esta en el manejo de algoritmos. Por lo que brindar una herramienta que facilite al instructor la enseñanza de una manera más interactiva y práctica beneficiará la asimilación de nuevos conocimientos por parte del alumno. Se pretende el desarrollo de la creatividad y el aumento de interés en estudiantes que se encuentran en niveles básicos de aprendizaje, brindándoles una herramienta que les permita diseñar algoritmos en diagramas de flujo de 17 datos y les permita manipularlo a su antojo para posteriormente generar la codificación en lenguaje de alto nivel. La aplicación está orientada a los nuevos programadores pero su interfaz permitirá que personas de cualquier otra disciplina de ingeniería puedan generar diagramas de flujo de datos en el que se detallen procesos como de producción, manufactura, de seguridad, etc. 1.5 OBJETIVOS. 1.5.1 OBJETIVO GENERAL. • Desarrollar un Editor e Intérprete de Diagrama de Flujo de Datos con generación de código en C++ y Java. 1.5.2 OBJETIVOS ESPECÍFICOS. • Desarrollo de un ambiente gráfico que facilite la interacción del usuario con la aplicación. • Minimizar los requerimientos de hardware para el funcionamiento de la aplicación. • Facilitar la creación, edición y almacenamiento de los diagramas de flujo de datos del usuario. • Generar herramientas de ejecución y depuración de fácil utilización y comprensión. • Generar codificación a los lenguajes Java y C++ del diagrama de flujo de manera sencilla y efectiva. • Generar diagramas de flujo ejemplos para que el usuario puede tener una biblioteca de algoritmos en el cual apoyarse. • Elaboración de un manual de usuario y archivos de ayuda para la comprensión completa de la herramienta. 18 1.6 ALCANCES. La aplicación se ha desarrollado utilizando Visual C++ 6.0 con Qt Designer 4.2.2, diseñado para correr en la plataforma Windows. La aplicación cuenta con una interfaz gráfica que facilita la creación y edición de diagramas de flujo de datos. El usuario puede guardar su diagrama de flujo de datos en el disco duro o en cualquier sistema de almacenamiento. Puede cargar un diagrama que haya creado anteriormente para modificarlo o examinarlo en profundidad. El usuario puede utilizar herramientas de ejecución como “Ejecución Paso a Paso” y una ventana de depuración que muestre como cambian los valores de las expresiones a medida que un algoritmo se ejecuta. Los errores que estén presentes en la sintaxis o en la evaluación de las expresiones en cualquier lugar del diagrama se mostraran al usuario en mensajes indicándole donde se encuentran. Antes de la ejecución del algoritmo se realizará una revisión completa del diagrama para garantizar que no haya problemas posteriores para la generación de código. El usuario podrá optar por generar el código al lenguaje C++ o Java del diagrama de flujo que se este utilizando. Se creará un archivo .cpp en el caso de C++ y .java para el caso de Java. Dicho archivo conteniendo el código podrá ser compilado y ejecutado en cualquier herramienta comercial o no comercial sin errores y deberá ejecutar el algoritmo que se ha representado en el diagrama de flujo. 1.7 DELIMITACIÓN. La aplicación generará la codificación hacia los lenguajes C++ y Java del diagrama de flujo con el cual se este trabajando, pero en ningún momento la aplicación será capaz de compilar ni ejecutar dicho código. 19 Se garantiza que el código generado sea efectivo y pueda ser procesado por cualquier herramienta comercial o no comercial como Microsoft Visual C++, Dev C++, etc. para el caso de C++ y NetBeans, JDeveloper, etc. para el caso de java. La aplicación no podrá utilizar funciones predefinidas por el usuario. 1.8 PROYECCIÓN SOCIAL. La base de la programación en computadoras esta en el manejo de algoritmos. Por lo que se pretende crear una aplicación gratuita y de libre distribución que facilite la comprensión y asimilación de conocimientos informáticos en el área de algoritmos para alumnos que se encuentran en sus primeros años de formación en las ciencias de la computación. Se quiere crear una herramienta que permita al instructor enseñar de una manera más dinámica conocimientos en el área de algoritmos que son la base para la comprensión de temas posteriores y que permitan al alumno pueda llevar a la practica los conocimientos que se van adquiriendo desde un principio para así potenciar su creatividad e interés por la computación. La facilidad de uso de la aplicación permitirá que usuarios de otras carreras de ingeniería puedan utilizar la aplicación para generar sus diagramas de flujo de datos en el cual estén plasmados procesos de producción, de seguridad, etc. 1.9 METODOLOGÍA DE LA INVESTIGACIÓN. La investigación realizada es directa como también de tipo experimental. En la primera fase se realizó la recopilación de la información, enfocada en la teoría de diagramas de flujo y en técnicas de programación que nos faciliten la interpretación y la generación de código. Como segunda fase se tuvo el diseño de la aplicación que permita generar diagramas de flujo de datos y brinde herramientas de depuración y ejecución. Así como también permita la generación de código en C++ y Java. 20 1.9.1 INVESTIGACIÓN BIBLIOGRÁFICA Se Investigó acerca de distintos componentes y herramientas de programación necesarias para la creación de un editor e intérprete de diagramas de flujo de datos. En el material utilizado se incluyen manuales, libros, e información existente en Internet. 1.9.2 ASESORÍA PROFESIONAL Se crearon sesiones con profesionales en la materia que tengan experiencia en programación y en aspectos didácticos, que nos permitieron recopilar mayor información acerca de los aspectos a vigilar en el desarrollo de la aplicación. 1.9.3 INFORMACIÓN DISPONIBLE EN INTERNET Una herramienta que permite la búsqueda de amplios conocimientos sobre programación y adquisición de herramientas de desarrollo de software. Para la investigación de el proyecto, Internet fue la herramienta de mayor potencial que se utilizó, encontrando documentación validada a nivel mundial, por reconocidas empresas dedicadas al rubro de software, así como también prestigiosas universidades a nivel mundial, como documentación de profesionales dedicados a compartir sus investigaciones por medio de Internet. 1.9.4 ESTUDIO TÉCNICO DE APLICACIONES EXISTENTES 1.9.4.1 DFD. Dfd® es un editor e intérprete de diagramas de flujo creado en 1997. Su interfaz gráfica facilita en gran medida la creación de diagramas de flujo para la representación de algoritmos que solucionan problemas por computadora. El programa Dfd® en su totalidad, fue realizado en lenguaje C++ utilizando programación orientada a objetos y corre bajo Windows a 32 bits, ver figura 1. El software Dfd® incluye un archivo de ayuda para Windows, que provee un fácil acceso a información necesaria para trabajar con Dfd®, documentación sobre los símbolos u objetos que conforman los diagramas, las funciones, los operadores, los mensajes de error y demás aspectos relacionados con Dfd®. 21 El software Dfd® se encuentra inscrito en el Registro Nacional de Derechos de Autor de Colombia, correspondiente al libro 13, tomo 3, partida 166. Figura 1. Pantalla principal del Dfd®. El Dfd® no posee la generación de código en lenguaje de alto nivel, además su interfaz pese a ser amigable tiene errores de diseño; además posee un error en cuanto a consumo de procesador ya que al utilizar la pantalla de diseño de diagrama el uso de procesador llega al 100% y se mantiene hasta que no se utilice cualquier otra función de la aplicación. 1.9.4.2 AUTOFLOWCHART 1.0 Figura 2. Pantalla principal de Auto FlowChart 1.0 AutoFlowchart es un programa que permita la esquematización a partir de un código fuente. Dicho esquema se puede expandir o encoger y el usuario puede predefinir las medidas del esquema. Permite mover y agrandar el esquema, se puede exportar dicho esquema al tipo de archivo Microsoft Word o de Mapa de Bits. Sirve a los programadores a visualizar la idea general del código fuente. 22 Diseñado para correr en cualquier versión de Windows, con un tamaño de 1.37 MB de archivo de instalación. Es libre para probar con una licencia de 30 días, el precio para adquirirlo es de $79. Soporta C, C++, VC++ (Visual C++ .NET) y Delphi. Esta aplicación hace lo contrario a la aplicación propuesta en este proyecto, ya que a partir del código fuente genera el DFD pero no permite la manipulación del mismo ni mucho menos utilizar herramientas de ejecución como ejecución paso a paso. Además su precio de adquisición es elevado, la única forma es adquirirlo a través de Internet. 1.9.4.3 SMARTDRAW. Este es un software que permite la creación detalladas de diagramas de una manera rápida y efectiva. Incluye cientos de plantillas profesionales. Soporta los siguientes tipos de diagramas: • Diagramas UML • Diagramas ERD (Entidad - Relacion) • Diagramas de flujo de datos (DFD) • SSADM • Mapa de sitios Web El precio de la licencia de este software es: • 1 usuario: $197 • 5 usuario: $885 • 10 usuario: $1495 Este software esta diseñado solo para crear Diagramas, no permite la manipulación a nivel de ejecución de los DFD y su precio de adquisición esta demasiado elevado. 23 Figura 3. Pantalla principal de SmartDraw 24 CAPITULO II MARCO TEORICO 25 2.1 REFERENCIAS HISTÓRICAS. La palabra algoritmo proviene del nombre del matemático llamado Muhammad ibn Musa al-Jwarizmi que vivió entre los siglos VIII y IX. Su trabajo consistió en preservar y difundir el conocimiento de la antigua Grecia y de la India. Sus libros eran de fácil comprensión, de ahí que su principal logro no fuera el de crear nuevos teoremas o corrientes de pensamiento, sino el de simplificar la matemática a punto tal que pudieran ser comprendidas y aplicadas por un mayor número de personas. Cabe destacar cómo señaló las virtudes del sistema decimal indio (en contra de los sistemas tradicionales árabes) y cómo explicó que, mediante una especificación clara y concisa de cómo calcular sistemáticamente, se podrían definir algoritmos que fueran usados en dispositivos mecánicos en vez de las manos (por ejemplo, ábacos). También estudió la manera de reducir las operaciones que formaban el cálculo. Es por esto que aun no siendo el creador del primer algoritmo, el concepto lleva aunque no su nombre, sí su pseudónimo. Así, de la palabra algorismo, que originalmente hacía referencia a las reglas de uso de la aritmética utilizando dígitos árabes, se evolucionó a la palabra latina, derivación de al-Khwarizmi, algobarismus, que más tarde mutaría a algoritmo en el siglo XVIII. La palabra ha cambiado de forma que en su definición se incluye a todos los procedimientos finitos para resolver problemas. Ya en el siglo XIX, se produjo el primer algoritmo escrito para un computador. La autora fue Ada Byron, en cuyos escritos se detallaban la máquina analítica en 1842. Por ello que es considerada por muchos como la primera programadora aunque, desde Charles Babbage, nadie completó su máquina, por lo que el algoritmo nunca se implementó. La falta de rigor matemático en la definición de "procedimiento bien definido" para los algoritmos trajo algunas dificultades a los matemáticos y lógicos del siglo XIX y comienzos de XX. Este problema fue en gran parte resuelto con la descripción de la máquina de Turing, un modelo abstracto de computadora formulado por Alan Turing, y la demostración de que cualquier método anticipado por otros matemáticos que pueda encontrarse para describir "procedimientos bien definidos" puede ser emulado en una máquina de Turing (una afirmación conocida como "tesis de Church-Turing"). 26 En la actualidad, el criterio formal para definir un algoritmo es que se trata de un proceso que puede implementarse en una máquina de Turing completamente especificada, o en alguno de los formalismos equivalentes 2.2 MARCO CONCEPTUAL. 2.2.1 COMPUTADORAS Y SOFTWARE. El software es un elemento totalmente intangible, pero sin este elemento una computadora no podría trabajar. Muchas veces se tiene una computadora en la que se quiere realizar un trabajo pero muchas de esas veces no es de conocimiento del usuario que para poder lograr el trabajo final o el resultado de este trabajo sea exitoso, la computadora debe pasar por una serie de trabajos intermedios; para que esto suceda de alguna forma se le debe dar la información a la computadora de cómo realizar los procesos intermedios para que esta pueda realizar su objetivo; dicha información se transmite a la computadora siguiendo una terminología determinada y esto es lo que conforma el software. Se han desarrollado diversas técnicas para analizar los trabajos que realiza la computadora, así como un conjunto de símbolos y palabras producto de los análisis efectuados para ordenar de modo racional los pasos que debe seguir la computadora para realizar el trabajo. Este conjunto de órdenes constituye lo que comúnmente se llama programa. A cada una de las órdenes que constituyen este programa se les llama instrucciones o sentencias. Dentro del software existe otro nivel complejo y especializado que se encarga de efectuar el enlace entre los programas y los elementos de hardware. Por esta razón el software se divide en dos apartados: • Software de Base. • Software de Aplicación. 27 2.2.2 SOFTWARE DE BASE Y DE APLICACIÓN. El software de base esta formado por los programas que sirven de enlace entres los programas escritos por un programador, con el fin de realizar un determinado trabajo y los elementos hardware de la computadora. El software base esta formado fundamentalmente por los siguientes elementos: • Traductores: intérpretes y compiladores. • El ensamblador. • Los programas de utilidad. • Sistema operativo. Siendo el sistema operativo el elemento principal del software de base. Por otra parte, el software de aplicación es todo el conjunto de programas escritos para resolver problemas específicos planteados por el usuario. 2.2.3 TRADUCTORES: INTÉRPRETES Y COMPILADORES. La computadora solo puede ejecutar instrucciones escritas en un lenguaje formado por secuencias de ceros y unos (código binario), al que normalmente se denomina lenguaje maquina. Para ello cualquier lenguaje de programación que no sea lenguaje maquina necesitara un proceso de traducción. Este proceso se lleva a cabo en los intérpretes y los compiladores. Cualquier lenguaje de programación se puede traducir mediante u interprete construido expresamente para este lenguaje, así que no existe un interprete único para todos los lenguajes. El trabajo de un interprete es de traducir las instrucciones del lenguaje de programación al lenguaje maquina, con el fin de que la computadora pueda ejecutar esas instrucciones. Los compiladores traducen las sentencias o instrucciones del lenguaje de programación y las convierten en un conjunto de instrucciones en lenguaje maquina directamente ejecutables por la computadora. El proceso de traducción del compilador no se realiza simultáneamente, como lo hace el intérprete, sino que se hace un proceso aparte. 28 2.3 FUNDAMENTOS DE INTÉRPRETES. 2.3.1 INTERPRETE. Un intérprete es un programa que analiza y ejecuta simultáneamente un programa escrito en un lenguaje fuente. En la Figura 4 se presenta el esquema general de un intérprete visto como una caja negra. Cualquier intérprete tiene dos entradas: un programa P escrito en un lenguaje fuente LF junto con los datos de entrada; a partir de dichas entradas, mediante un proceso de interpretación va produciendo unos resultados. Figura 4. Esquema general de un intérprete. Los compiladores a diferencia de los interpretes, transforman el programa a un programa equivalente en un código objeto a esto s ele conoce como fase de compilación, y en un segundo paso generan los resultados a partir de los datos de entrada a esto se le conoce como fase de ejecución tal como se muestra en la Figura 5. Figura 5. Esquema general de un compilador 2.3.2 ESTRUCTURA DE UN INTÉRPRETE. A la hora de construir un intérprete es conveniente utilizar una Representación Interna (RI) del lenguaje fuente a analizar. De esta forma, la organización interna de la mayoría de los intérpretes se descompone en los módulos, ver figura 6: 29 1 Traductor a Representación Interna : Toma como entrada el código del programa P en Lenguaje Fuente, lo analiza y lo transforma a la representación interna correspondiente a dicho programa P. 2 Representación Interna (P/RI): La representación interna debe ser consistente con el programa original. Entre los tipos de representación interna, los árboles sintácticos son los más utilizados y, si las características del lenguaje lo permiten, pueden utilizarse estructuras de pila para una mayor eficiencia. 3 Tabla de símbolos : Durante el proceso de traducción, es conveniente ir creando una tabla con información relativa a los símbolos que aparecen. La información a almacenar en dicha tabla de símbolos depende de la complejidad del lenguaje fuente. Se pueden almacenar etiquetas para instrucciones de salto, información sobre identificadores (nombre, tipo, línea en la que aparecen, etc.) o cualquier otro tipo de información que se necesite en la etapa de evaluación. 4 Evaluador de Representación Interna: A partir de la Representación Interna anterior y de los datos de entrada, se llevan a cabo las acciones indicadas para obtener los resultados. Durante el proceso de evaluación es necesario contemplar la aparición de errores. 5 Tratamiento de errores : Durante el proceso de evaluación pueden aparecer diversos errores como desbordamiento de la pila, divisiones por cero, etc. que el intérprete debe contemplar. Figura 6. Organización interna de un intérprete. 30 Dependiendo de la complejidad del código a analizar, el intérprete puede contener módulos similares a los de un compilador tradicional: Análisis léxico, Sintáctico y Semántico. Durante la evaluación, el intérprete interactúa con los recursos del sistema como la memoria, discos, etc. Muchos sistemas interpretados liberan al programador del manejo explícito de memoria mediante técnicas de recolección de basura. A la hora de evaluar la representación interna, existen dos métodos fundamentales: la interpretación iterativa y la interpretación recursiva. a) Interpretación Iterativa La interpretación iterativa es apropiada para lenguajes sencillos, donde se analiza y ejecuta cada expresión de forma directa, como podrían ser los códigos de máquinas abstractas o lenguajes de sentencias simples. La interpretación consiste en un ciclo básico de búsqueda, análisis y ejecución de instrucciones. El esquema sería: Inicializar REPETIR Buscar siguiente Instrucción i SI encontrada ENTONCES Analizar i Ejecutar i HASTA (que no haya más instrucciones) Cada instrucción se busca en el almacenamiento (memoria o disco) o, en algunos casos, es introducida directamente por el usuario. Luego la instrucción es analizada en sus componentes y ejecutada. Normalmente, el lenguaje fuente contiene varios tipos de instrucciones, de forma que la ejecución se descompone en varios casos, uno por cada tipo de instrucción. b) Interpretación Recursiva Comúnmente, el diseño de nuevos lenguajes de programación se realiza en dos fases: 31 Una primera fase de especificación semántica mediante la construcción de un intérprete prototipo que actúa como una especificación ejecutable y una segunda fase de implementación del compilador de dicho lenguaje. Para la construcción de prototipos suele utilizarse un modelo de interpretación recursiva donde las sentencias pueden estar compuestas de otras sentencias y la ejecución de una sentencia puede lanzar la ejecución de otras sentencias de forma recursiva. Los intérpretes recursivos no son apropiados para aplicaciones prácticas debido a su ineficiencia y se utilizan únicamente como prototipo ejecutable del lenguaje. El problema de especificar un lenguaje mediante un intérprete prototipo es decidir en qué lenguaje se implementa dicho intérprete. Dicho lenguaje debe ser suficientemente expresivo y no ambiguo para definir claramente cómo funcionan las diferentes construcciones. En muchos casos se opta por utilizar lenguajes ya implementados pero que carecen de una especificación semántica clara. La tendencia actual es investigar técnicas de especificación semántica formal que permitan generar automáticamente este tipo de intérpretes. 2.3.3 VENTAJAS DE LA UTILIZACIÓN DE INTÉRPRETES. En general, la utilización de compiladores permite construir programas más eficientes que los correspondientes interpretados. Esto es debido a que durante la ejecución de código compilado no es necesario realizar complejos análisis; un buen compilador es capaz de detectar errores y optimizar el código generado. Los interpretes, por definición realizan la fase de análisis y ejecución a la vez, lo cual imposibilita las optimizaciones. Por lo tanto los sistemas interpretados suelen ser menos eficientes que los compilados. No obstante, con los nuevos avances informáticos aumentan la velocidad de procesamiento y capacidad de memoria de los computadores. Actualmente, la eficiencia es un problema menos grave y muchas veces se prefieren sistemas que permitan un desarrollo rápido de aplicaciones que cumplan fielmente la tarea encomendada. 32 2.3.4 VENTAJAS DE INTERPRETAR FRENTE A COMPILAR. A continuación se enumeran algunas ventajas de los sistemas interpretados: • Los intérpretes son más sencillos de implementar. Esto facilita el estudio de la corrección del intérprete. • Proporcionan una mayor flexibilidad. Esto permite modificar y ampliar características del lenguaje fuente. • No es necesario contener en memoria todo el código fuente. Esto permite la utilización en sistemas de poca memoria o en entornos de red. • Facilitan la meta-propagación. Un programa puede manipular su propio código fuente a medida que se ejecuta. • Aumentan la portabilidad del lenguaje. Para que el lenguaje interpretado funcione en otra maquina solo es necesario que su interprete funcione en dicha maquina. • Facilitan el desarrollo rápido de prototipos. Ya que no existen etapas intermedias de compilación. • Potencian la utilización de sistemas interactivos y facilitan las tareas de depuración. 2.3.5 APLICACIONES DE SISTEMAS BASADOS EN INTÉRPRETES. Los sistemas interpretados han tenido una gran importancia desde la aparición de los primeros computadores. En la actualidad la evolución del hardware abre nuevas posibilidades a los sistemas interpretados. La preocupación ya no es tanto la eficiencia como la capacidad de desarrollo rápido de nuevas aplicaciones. Las que se podrían resumir como principales aplicaciones son las siguientes: • Intérpretes de Comandos: los sistemas operativos cuentan con los intérpretes de comandos como el Korn-shell, C-Shell, JCL, etc. Estos intérpretes toman un lenguaje fuente que puede incluir sentencias de control y ejecutan los diferentes comandos a medida que aparecen en el lenguaje. 33 • Lenguajes basados en Escritos: diseñados como herramientas que sirvan de enlace entre diferentes sistemas o aplicaciones. Suelen ser interpretados con el fin de admitir una mayor flexibilidad a la hora de afrontar cada sistema. • Entornos de Programación: existen ciertos lenguajes que contienen características que impiden su compilación o no es efectiva. Estos lenguajes suelen tener disponer de un complejo entorno de desarrollo interactivo con facilidades para la depuración de programas. • Lenguajes de Propósito Específico: ciertos lenguajes incluyen sentencias que realizan tareas complejas en contextos específicos. • Sistemas de Tiempo Real: entornos que permiten modificar el código de una aplicación en tiempo de ejecución de forma interactiva. • Intérprete de código Intermedio: una tendencia tradicional de compiladores es la generación de código intermedio para una maquina abstracta; el siguiente paso puede ser la generación de código objeto a partir del código intermedio para una maquina concreta, finalizando el proceso de compilación o interpretar dicho código intermedio en una maquina concreta. 2.3.6 TIPOS DE INTÉRPRETES. Existen diferentes métodos de interpretación según la estructura interna del intérprete. Es conveniente observar que algunos métodos podrían considerarse híbridos ya que mezclan los procesos de compilación e interpretación. Intérpretes Puros: Son los que analizan y ejecutan sentencia por sentencia todo el programa fuente. Siguen el modelo de interpretación iterativa y por tanto se utilizan principalmente para lenguajes sencillos. Los intérpretes puros se han utilizado desde la primera generación de computadoras al permitir la ejecución de largos programas en computadores de memoria reducida, ya que solo debían contener en memoria el intérprete y la sentencia a analizar y ejecutar en cada momento. El principal problema de este intérprete es que si a mitad del programa fuente se producen errores, se debe volver a comenzar el proceso. La Figura 7 muestra el esquema de un intérprete puro. 34 Figura 7. Esquema de un intérprete puro Intérpretes Avanzados o Normales: Incorporan un paso previo de análisis de todo el programa fuente. Generando posteriormente un lenguaje intermedio que es ejecutado por ellos mismos. De esta forma en caso de errores sintácticos no pasan de la fase de análisis; se utilizan para lenguajes más avanzados que los intérpretes puros, ya que permiten realizar un análisis mas detallado del programa fuente. Intérpretes Incrementales: Existen ciertos tipos de lenguajes que por sus características, no se pueden compilar directamente. La razón es que pueden manejar objetos funciones que no son conocidos en tiempo de compilación, ya que se crean dinámicamente en tiempo de ejecución. Con el propósito de obtener mayor eficiencia que la interpretación simple, se diseñan los compiladores incrementales. La idea es compilar aquellas partes estáticas del programa en lenguaje fuente, marcando como dinámicas las que no puedan compilarse. Posteriormente en tiempo de ejecución, el sistema podrá compilar algunas partes dinámicas o recompilar partes dinámicas que hayan sido modificadas. Estos sistemas no producen un código objeto independiente, sino que acompañan al sistema que permite compilar módulos en tiempo de ejecución. Generalmente los compiladores incrementales se utilizan en sistemas interactivos donde conviven módulos compilados con módulos modificables. Evaluadores Parciales: La utilización de evaluadores parciales o especializadores surge al considerar que muchos programas contienen dos tipos de datos de entrada. Existen una serie de datos de entrada que son diferentes en cada ejecución mientras que otros datos no varían de una ejecución a otra. 35 El primer conjunto se conoce como datos de entrada dinámicos, mientras que el segundo conjunto serian los datos de entrada estáticos. La principal ventaja de la evaluación parcial es la eficiencia. Compiladores "Just in Time": Con la aparición de Internet surge la necesidad de distribuir programas de una forma independiente de la maquina permitiendo su ejecución en una amplia variedad de plataformas. Las ventajas de la interpretación Just in Time son: • Los Programas grandes contienen porciones de código que no son ejecutadas en una ejecución típica del programa. • Los sistemas tradicionales realizan la compilación de todo el código antes de la ejecución, lo que para el usuario puede presentar un lapso de tiempo substancial entre el momento en que todas las unidades de compilación han sido transmitidas y el momento en que la ejecución puede comenzar. Compilación Continua: surge como un intento de mejorar la compilación "Just in time". El sistema mezcla el proceso de compilación a código nativo con el proceso de interpretación. Para lograr esto el sistema dispone de dos módulos: un modulo de interpretación de los códigos de bytes y otro modulo de compilación de códigos de bytes a código nativo. La idea consiste en que ambos módulos actúen a la vez a modo que el sistema no se detenga a compilar un modulo, sino que vaya interpretando hasta que le compilador haya generado el código nativo. Estos son los módulos que intervienen en este tipo de compilación: • CODIGO: Contiene una mezcla de código fuente y código nativo del programa. Inicialmente todo el código esta sin compilar, pero a medida que el programa es ejecutado, el compilador genera traducciones a código nativo de las unidades de compilación. • COMPILADOR: El modulo compilador traduce las unidades de compilación a código nativo. A medida que se finaliza la traducción de una unidad, la versión en código nativa se deja disponible al intérprete. 36 • INTERPRETE: El modulo interprete se responsabiliza de la ejecución actual del programa. comienza interpretando del código fuente, haciendo saltos a las versiones en código nativo a medida que estas están disponibles. • MONITOR: Se encarga de coordinar la comunicación entre los dos módulos anteriores. La principal ventaja de la compilación continua respecto a la compilación Just in time radica en no tener que esperar a compilar una unidad para comenzar su ejecución. 2.4 COMPILADORES. Un compilador es un programa que, a su vez, traduce un programa escrito en un lenguaje de programación a otro lenguaje de programación, generando un programa equivalente. Usualmente el segundo lenguaje es código maquina, pero también puede ser simplemente texto. Este proceso de traducción se conoce como compilación la Figura 8 muestra el proceso de compilación. Figura 8. Esquema del proceso de compilación. 37 La razón principal para querer usar un compilador es querer traducir un programa de un lenguaje de alto nivel, a otro lenguaje de nivel inferior. De esta manera un programador puede diseñar un programa en un lenguaje mucho más cercano a como piensa el humano, para luego compilarlo a un programa más manejable por una computadora. En pocas palabras un compilador es cualquier programa que toma como entrada un texto escrito en un lenguaje, llamado fuente y da como salida otro texto en un lenguaje denominado objeto tal como lo muestra la Figura 9. Figura 9. Esquema de la función de un compilador. 2.4.1 HISTORIA DE LOS COMPILADORES. La palabra compilador se atribuye a Grace Murray Hopper quien visualizo la implementación de un lenguaje de alto nivel, de forma bastante precisa para su época. Los primeros compiladores fueron escritos a fines de los años 50. Se dice que FORTRAN fue el primer lenguaje compilado que tomo 18 años desarrollarlo, esto sucedió ya que se desarrollaba el lenguaje al mismo tiempo que se desarrollaba; el compilador fue diseñado para obtener el mejor código posible. 2.4.2 PARTES DE UN COMPILADOR. Normalmente los compiladores están divididos en dos partes: • FRONT END: Es la parte analiza el código fuente, comprueba su validez, genera el árbol de derivación y rellena los valores de las tabla de símbolos. Esta parte suele ser independiente de la plataforma o sistema para el cual se vaya a compilar. • BACK END: Es la parte que genera el código maquina, especifico de una plataforma, a partir de los resultados de la fase de análisis, realizada por el Front End. 38 Esta división permite que el mismo Back End se utilice para generar el código maquina de varios lenguajes de programación distintos y que el mismo Front End que sirve para analizar el código fuente de un lenguaje de programación concreto sirva para la generación de código maquina en varias plataformas distintas. El código que genera el Back End normalmente no se puede ejecutar directamente, sino que necesita ser enlazado por un programa enlazador. 2.4.3 TIPOS DE COMPILADORES. Compiladores Optimizadores : Realizan cambios en el código para mejorar su eficiencia, pero la funcionalidad del programa original. Compiladores de una Sola Pasada : Generan el código maquina a partir de una única lectura del código fuente. Compiladores de Varias Pasadas: Necesitan leer el código fuente varias veces antes de poder producir el código maquina. Compiladores Just In Time: Forman parte de un intérprete y compilan partes del código según se necesitan. Compiladores Incrementales: Generan un código objeto instrucción por instrucción, cuando el usuario teclea cada orden individual. Los demás tipos de compiladores requieren que todos los enunciados o instrucciones se compilen conjuntamente. Ensamblador: El lenguaje fuente es lenguaje ensamblador y posee una estructura sencilla. Compilador Cruzado: se genera código en lenguaje objeto para una maquina diferente de la que se esta utilizando para compilar. Compilador con Montador: Compila distintos módulos de forma independiente y después es capaz de enlazarlos. 39 Autocompilador: Esta escrito en el mismo lenguaje que va a compilar. Evidentemente nos e puede ejecutar la primera vez, sirve para hacer aplicaciones al lenguaje, mejorar el código generado. Metacompilador: es sinónimo de compilador de compiladores y se refiere a un programa que recibe como entrada las especificaciones del lenguaje para el que se desea obtener un compilador y genera como salida el compilador para ese lenguaje. El desarrollo de los metacompiladores se encuentra con la dificultad de unir la generación de código con la parte de análisis. Descompilador: Es un programa que acepta como entrada código maquina y lo traduce a un lenguaje de alto nivel, realizando el proceso inverso a la compilación. 2.4.4 FASES DE LA COMPILACIÓN. Es el proceso de traducción de programas fuentes a programas objeto. El programa obtenido de la compilación ha sido traducido normalmente a lenguaje maquina. Para conseguir el programa maquina real de debe utilizar un programa llamado montador o enlazador (linker). El proceso de montaje conduce a un programa en lenguaje maquina directamente ejecutable. El proceso de ejecución de un programa escrito en un lenguaje de programación y mediante un compilador tiene los siguientes pasos: • Escritura del programa fuente con un editor y guardarlo en un dispositivo de almacenamiento. • Introducir el programa fuente en memoria. • Compilar el programa con el compilador. • Verificar y corregir errores de compilación. • Obtención del programa objeto. • El enlazador obtiene el programa ejecutable. • Se ejecuta el programa y si no existen errores, se tendrá la salida del programa. 40 2.4.5 FORMA DE EXAMINAR DE UN COMPILADOR. En la compilación hay dos partes, análisis y síntesis. La parte del análisis divide al programa fuente en sus elementos componentes y crea una representación intermedia. De las dos partes, la síntesis es la que requiere la técnica mas especializada. Durante el análisis se determina las operaciones que implica el programa fuente y se registra en una estructura jerárquica llamada árbol. Se usa una clase especial de árbol llamado árbol sintáctico, donde cada nodo representa una operación y los hijos de un nodo son los argumentos de la operación. 2.4.6 ANÁLISIS DE UN CÓDIGO FUENTE. Para que el compilador pueda analizar el código fuente es necesario que realice tres procesos de análisis los cuales son: análisis Léxico, análisis Léxico y análisis Semántico. • análisis Léxico: también es conocido como scanner, lee los caracteres uno a uno desde la entrada y va tomando grupos de caracteres con alguna relación entre si a los cuales se les denomina Tokens, que constituirán la entrada para la siguiente etapa del compilador. Cada Token es una secuencia de caracteres que son tratados como una única entidad. • análisis sintáctico: también es llamado como Parser, recibe como entrada los tokens que le pasa el Analizador Léxico y comprueba si esos tokens van llegando en el orden correcto. La salida teórica de la fase de análisis seria un árbol sintáctico. • análisis Semántico: Es posterior al sintáctico y mucho mas difícil de formalizar que este. Se trata de determinar el tipo de resultados intermedios, comprobar que los argumentos que tiene un operador pertenecen al conjunto de los operadores posibles, y si son compatibles entre si. Es decir se comprobara que el significado de lo que se va leyendo es valido. 41 2.4.7 VENTAJAS DE COMPILAR FRENTE A INTERPRETAR. • Se compila una vez, y se puede ejecutar múltiples veces. • En bucles, la compilación genera código equivalente al bucle, pero interpretándolo se traduce tantas veces una línea como veces se repite el bucle. • El compilador tiene una visión global del programa, por lo que la información de mensajes de error es más detallada. 2.5 COMPILADORES E INTÉRPRETES EN GENERAL. Un compilador traduce un programa escrito en lenguaje fuente a un lenguaje objeto de bajo nivel, el cual puede ser lenguaje ensamblador o lenguaje de maquina de una computadora particular. El programa que se escribe en el lenguaje fuente es llamado programa fuente, el cual se edita en uno o más archivos fuentes. El compilador traduce cada archivo fuente a un archivo objeto, si el archivo fuente contiene lenguaje ensamblador se debe correr un ensamblador para convertirlos a lenguaje maquina, luego se corre un lenguaje de utilidad llamado linker (vinculador) para combinar los archivos objeto a un programa objeto. Una vez creado, se puede cargar en la memoria de una computadora y ejecutarse. Un compilador puede también traducir primero el programa fuente a un código intermedio y luego traducir el código intermedio en un lenguaje objeto. Por otro lado, un intérprete no produce un programa objeto. Puede traducir un programa fuente a un código intermedio interno que se puede ejecutar más eficientemente, o podría simplemente ejecutar las sentencias del programa directamente. Esto quiere decir que el intérprete traduce un programa a las acciones especificadas por el programa. 2.5.1 DIFERENCIAS ENTRE COMPILADORES E INTÉRPRETES. Básicamente lo que el compilador hace para ejecutar el programa es revisar completamente el código del programa para determinar si no hay ningún error de sintaxis, si el compilador no encontró ningún error entonces ejecuta el programa, en caso contrario lo que hará es finalizar la compilación e indicar que ha encontrado errores en el código y no ejecutara el programa. 42 Por otro lado el interprete verifica una línea del código y ejecuta esa línea si se llegara a encontrar con un error el programa se termina en ese instante y se debe comenzar a ejecutarlo desde el principio una vez mas. 2.5.2 VENTAJAS Y DESVENTAJAS DE LOS COMPILADORES E INTÉRPRETES. • Al ejecutar un programa fuente con un intérprete, simplemente se carga el programa fuente al intérprete, y este revisa y ejecuta el programa. Un compilador revisa el programa fuente y produce un programa objeto. Después de correr el compilador, podría ser necesario correr un linker para luego cargar el programa objeto en la memoria para poder ejecutarlo; si el compilador generara un programa objeto en lenguaje ensamblador, también se debe correr un ensamblador. Así que un intérprete definitivamente tiene ventajas ante un compilador cunado se trata sobre el esfuerzo requerido para ejecutar el programa fuente. • Los intérpretes pueden ser más versátiles que los compiladores. Teniendo en mente que los intérpretes son programas por si mismos, y como cualquier otro programa pueden ser creados para ejecutarse en diferentes computadoras. Un compilador sin embargo genera programas objetos para una computadora en particular. • Uno de los casos que podría pasar es que el programa fuente contenga un error lógico que no aparece hasta el tiempo de ejecución; como un interprete tiene el control cuando esta ejecutando el programa fuente, puede parar e indicar el numero de línea de la sentencia que contiene el error y el nombre de la variable; incluso puede dar alguna ayuda de cómo corregir el error antes de reanudar con la ejecución. El programa objeto generado por un compilador, por un lado, usualmente se ejecuta el mismo. Información del programa fuente tales como números de línea y nombres de variables, podrían no ser presentes en el programa objeto. 43 Cuando ocurre un error en tiempo de ejecución, el programa simplemente termina y tal vez imprima un mensaje conteniendo la dirección de la instrucción con error, depende del programador averiguar que sentencia pertenece a la dirección de el error y que variable esta errónea. • Cuando se trata de depurar, un intérprete es generalmente la mejor opción. Sin embargo ahora muchos ambientes de desarrollo de programas modernos tienen compiladores con la capacidad de depurar casi tan bien como los interpretes. Se compila un programa y luego se ejecuta bajo el control del ambiente; si un error ocurre en tiempo de ejecución, es mostrada la información y control necesarios para corregir el error, luego se puede reanudar la ejecución del programa, o compilar y correr luego. Tales compiladores no obstante generan información extra o instrucciones en el programa objeto para mantener el ambiente informado de la situación actual de la ejecución; esto usualmente hace que el programa objeto se menos eficiente de lo que podría ser. • Después de haber depurado el programa la interrogante será la velocidad con que el programa correrá. Teniendo en cuenta que el interprete ejecuta las instrucciones del código fuente línea por línea, cada vez que ejecute una línea de instrucción la revisa para determinar que operación se le ordena realizar. Con un compilador, la computadora ejecuta un programa de lenguaje maquina, generado ya sea directamente por un compilador o directamente con un ensamblador. Desde que una computadora ejecuta el lenguaje maquina a una alta velocidad así como un programa puede correr desde 10 a 100 veces más rápido que un programa fuente interpretado. De este modo un programa compilado es mas rápido que un programa interpretado, esto es verdad en el caso de un compilador que genere especialmente código eficiente. 2.6 ALGORITMOS. El programador no es más que una persona que resuelve problemas, pero para que este programador llegue a ser eficaz debe resolver los problemas de una forma rigurosa y sistemática. 44 Problema Diseño del Algoritmo Programa de Computadora Un algoritmo es un método para resolver un problema, la resolución de un problema exige el diseño de un algoritmo que resuelva el problema propuesto tal como lo muestra la siguiente figura que muestra la resolución de un problema. Figura 10. Pasos para la resolución de un problema Pasos Para la resolución de un Problema: 1. Diseño del algoritmo, que describe la secuencia ordenada de los pasos que conducen a la solución de un problema dado. A esto se le denomina Análisis del problema y Desarrollo del algoritmo. 2. Expresar el algoritmo como un programa en un lenguaje de programación adecuado. 3. Ejecución y validación del programa por la computadora. Para llegar a la realización de un programa es necesaria la realización previa de un algoritmo. Los algoritmos son independientes tanto del lenguaje de programación en que se expresan como de la computadora en que se ejecuten. En cada problema el algoritmo se puede expresar en un lenguaje de programación diferente y ejecutarse en una computadora distinta. No obstante el algoritmo será el mismo. En la computación los algoritmos son más importantes que los lenguajes de programación o las computadoras. Un lenguaje de programación es tan solo un medio para expresar el algoritmo y una computadora es solo un procesador para ejecutarlo. Tanto el lenguaje de programación como la computadora son los medios para obtener un fin. La definición de un algoritmo debe describir tres partes: Entrada, Proceso y Salida. 2.6.1 CARACTERÍSTICAS DE LOS ALGORITMOS. • Un algoritmo debe ser preciso e indicar el orden de realización de cada paso. 45 • Un algoritmo debe estar definido. Si se sigue un algoritmo dos veces se debe obtener el mismo resultado las dos veces. • Un algoritmo debe ser finito. Las técnicas de desarrollo y diseño de programas que se utilizan en la programación convencional tienen inconvenientes, sobre todo a la hora de verificar y modificar dicho programa. Hoy en día están adquiriendo gran importancia las técnicas de programación, cuyo objetivo principal es de facilitar la comprensión del programa y además permiten de forma rápida, las ampliaciones y modificaciones que surjan en la fase del ciclo de vida de un sistema. En la programación convencional de suele hacer uso indiscriminado sin control de las instrucciones de salto condicional e incondicional, esto produce cierta complejidad en el entendimiento y modificación de los programas. Eliminar esta complejidad es una característica de la programación estructurada y por eso se ha definido como la técnica de programación sin saltos condicionales e incondicionales. De una forma general los Diagramas de flujos de datos son graficas dirigidas en donde los nodos especifican las actividades del proceso y los arcos la transferencia de datos entre los nodos. Un diagrama de flujos de datos representa el flujo de datos entre estatutos individuales o entre bloques de estatutos dentro de una rutina; flujo de datos entre rutinas secuenciales, flujos de datos entre procesos concurrentes o flujos de datos entre sistemas de computo distribuidos, donde cada nodo representa una unidad de proceso geográficamente separada. Distinto a otros diagramas de flujo, las burbujas no indican la lógica de decisión o las condiciones bajos las cuales varios nodos de proceso se activen. Los diagramas de datos pueden expresarse utilizando una notación informal o por medio de símbolos especiales para denotar a los nodos de proceso a los nodos de entrada. Los diagramas generales especifican los procesos de un sistema en forma funcional, cada diagrama describe la entrada, los pasos del proceso y la salida para la función en cuestión, un diagrama general puede indicar la localización de los diagramas de detalles subordinados necesarios. 46 2.7 DIAGRAMAS DE FLUJO DE DATOS (DFD). Los diagramas de flujo representan la forma más tradicional para especificar y documentar los detalles algorítmicos de un producto de programación. Los diagramas de flujo son una representación grafica de los pasos de un proceso, útil para determinar como funciona realmente el proceso para producir un resultado; representan la forma más tradicional para especificar los detalles algorítmicos de un proceso. El resultado puede ser un producto, un servicio, información o una combinación de los tres. Se utilizan principalmente en programación, economía y procesos industriales. Estos diagramas utilizan una serie de símbolos que representan las funciones de los programas, y de líneas de flujo, que denotan la secuencia en la que se deberán realizar estas funciones. Las instrucciones se escriben dentro de los símbolos (ver figura 11). Son modelos tecnológicos utilizados para comprender los rudimentos de la programación lineal. En los diagramas de flujos hay literalmente docenas de símbolos orientados a utilizarse para la representación de los pasos del los diagramas de flujo en los cuales los más comunes se encuentran: Símbolo Descripción Inicio / Terminación. Este símbolo se utiliza para señalar el comienzo así como el final de un diagrama. Tradicionalmente se colocan las palabras “INICIO” ó “FIN” dentro de la figura para hacerlo más explícito. Proceso de datos. Este símbolo se utiliza para señalar operaciones matemáticas, aritméticas o procesos específicos que se realicen con nuestros datos. Decisión. Este símbolo representa una disyuntiva lógica o decisión. En su interior se anota una instrucción o pregunta que pueda ser evaluada como cierta o falsa y que determine el flujo del programa. Desplegado de información. Este símbolo se utiliza para mostrar un resultado, el cual puede representar la solución al problema que se pretende resolver y que fue conseguida a través del resto del diagrama. 47 Tabla 1.Simbología de diagrama de flujo de datos En la diagramación, también contamos con una serie de símbolos auxiliares que no intervienen en el proceso del algoritmo, pero que pueden ser útiles para ayudarnos a dar claridad a nuestros diagramas, algunos de ellos son los siguientes: Símbolo Descripción Conector. Este símbolo se utiliza para indicar un salto dentro del diagrama. Se utiliza con el propósito de facilitar la disposición plana de un diagrama y evitar el cruce excesivo de líneas a través del mismo. Conector de página. Este conector es idéntico en funcionamiento que el anterior, pero su forma pentagonal lo distingue e indica que debemos buscar el “gemelo” en una página distinta de la actual. Este conector lleva asociado una especie de salto entre páginas. Tabla 2.Conectores de diagramas de flujo de datos Cabe mencionar que no se debe abusar del uso de conectores pues de lo contrario comenzaría a perderse la claridad que se pretende alcanzar con el diagrama. Ejemplo de un diagrama de flujo simple: Figura 11. Ejemplo de un Diagrama de Flujo de Datos. Entrada Manual de Datos. Sirve también para la introducción de datos desde el teclado. Entrada/Salida. Entrada de datos introducidos por el teclado muchas veces este símbolo es utilizado también como salida de datos 48 Los diagramas de flujo se leen de arriba hacia abajo, como lo indican las líneas de flujo. La única variación que se hace a esta lectura vertical es la efectuada es al instante en el que se encuentra con una decisión, lo que podría hacer un cambio en la secuencia. Para funciones de entrada/salida, por lo general un símbolo representa una sola instrucción. Sin embargo, para funciones de procesamiento podemos combinar una o más instrucciones de procesamiento estrechamente relacionadas dentro de un solo símbolo de procesamiento. Este método de representación permite que los diagramas de flujo sean más sencillos y más cortos, así como también facilita la lectura del diagrama de flujo para quien quiera comprender la función que se va a realizar. El enunciado dentro de cada símbolo no tiene que ser único, se pueden utilizar muchos otros, siempre y cuando el significado preciso sea claro. Otra definición del diagrama de flujo es la siguiente: “Es un esquema para representar gráficamente un algoritmo. Se basan en la utilización de diversos símbolos para representar operaciones específicas. Se les llama diagramas de flujo porque los símbolos utilizados se conectan por medio de flechas para indicar la secuencia de operación. Para hacer comprensibles los diagramas a todas las personas, los símbolos se someten a una normalización; es decir, se hicieron símbolos casi universales, ya que, en un principio cada usuario podría tener sus propios símbolos para representar sus procesos en forma de Diagrama de Flujo. Esto trajo como consecuencia que sólo aquel que conocía sus símbolos, los podía interpretar. La simbología utilizada para la elaboración de diagramas de flujo es variable y debe ajustarse a un patrón definido previamente.” 49 Figura 12. Ejemplo de diagrama de flujo. 2.7.1 REGLAS PARA LA CREACIÓN DE DIAGRAMAS. 1. Los Diagramas de flujo deben escribirse de arriba hacia abajo, y/o de izquierda a derecha. 2. Los símbolos se unen con líneas, las cuales tienen en la punta una flecha que indica la dirección que fluye la información procesos, se deben de utilizar solamente líneas de flujo horizontal o verticales (nunca diagonales). 3. Se debe evitar el cruce de líneas, para lo cual se quisiera separar el flujo del diagrama a un sitio distinto, se pudiera realizar utilizando los conectores. Se debe tener en cuenta que solo se vana utilizar conectores cuando sea estrictamente necesario. 4. No deben quedar líneas de flujo sin conectar 5. Todo texto escrito dentro de un símbolo debe ser legible, preciso, evitando el uso de muchas palabras. 6. Todos los símbolos pueden tener más de una línea de entrada, a excepción del símbolo final. 7. Solo los símbolos de decisión pueden y deben tener más de una línea de flujo de salida. Los diagramas de flujo describen los procesos que cambian o transforman los datos en un sistema, las entidades externas que son fuentes o destinos de los datos y los almacenamientos o depósitos de datos a los cuales tiene acceso el sistema. 50 En síntesis, el diagrama de flujos de datos describe: • Los lugares de origen y destino de los datos (los limites del sistema). • Las transformaciones a las que son sometidos los datos (los procesos internos). • Los lugares en los que se almacenan los datos dentro del sistema. • Los canales por donde circulan los datos. Con lo anteriormente mencionado se puede sostener que antes de codificar un programa, se debe dibujar un diagrama de flujo que exhiba la secuencia de las etapas de programación que se deberán codificar. La elaboración de diagramas de flujo consiste en comprender el flujo lógico de los procesamientos que se pueden realizar en la computadora. La razón de que el programador elabore diagramas de flujo es para asegurarse de que las etapas que se codificaran en el programa se integraran adecuadamente. 2.7.2 NACIMIENTO DE LOS DIAGRAMAS DE FLUJOS. En un principio la programación estructurada fue desarrollada en sus principios por Edgar w, Dijkstra en sus Notes and Structure Programming y se basa en el denominado Teorema de la Estructura desarrollado en 1966 por Bomh y Jacopini, que se ratifico con los trabajos de Charlan D. Mills. En la actualidad existen diversas definiciones de estos diagramas pero todas ellas giran alrededor del Teorema de Estructura, técnica que se basa a través de módulos o bloques. Para entender el Teorema de Estructura es necesario primero verificar algunos conceptos que trata este teorema. 1. Diagrama Propio: es aquel que posee un solo punto de entrada y uno de salida. 2. Programa Propio: es aquel programa que cumple con las siguientes condiciones: • Posee un solo inicio y un solo fin. • Todo elemento del programa es accesible, es decir, existe al menos 51 un camino desde el inicio al fin que pasa a través de el. • No posee bucles infinitos. 3. Teorema de la Estructura: todo programa propio realice el programa que realice, tiene al menos un programa propio equivalente que solo utiliza las estructuras básicas de la programación que son: • La secuencia • La selección • La repetición 2.7.3 CARACTERÍSTICAS DE LOS DIAGRAMAS ESTRUCTURADOS. Generalmente en las empresas se dispone de distintas personas para darle mantenimiento a un sistema y estas personas muchas veces son constantemente trasladas a otros puesto, es por eso que la importancia de realizar Diagramas de Flujo del sistema lo mas detallado y explicado posible es muy vital, así que no es necesario que el programador del sistema este asesorando todo el tiempo a cada una de las personas que tendrán a cargo dicho sistema. El diseñador de la aplicación debe tener en cuenta todo el tiempo que no solo el tendrá acceso a los diagramas de flujo de dicha aplicación es por eso que los debe desarrollar los mas fácil posible en comprensión, para que a la otra persona le sea fácil la modificación y mantenimiento de la aplicación. Por tal cuestión el Diagrama Estructurado ofrece muchas ventajas para lograr estos objetivos. Dicho esto se puede decir que los Diagramas Estructurados son: • fácil de leer y comprender. • fácil de codificar en una amplia gama de lenguajes y en diferentes sistemas. • fácil de mantener. • Eficiente, aprovechando al máximo los recursos de la computadora. 52 A B C A BA Alternativa Alternativa 2.7.4 PRINCIPALES ESTRUCTURAS DE LOS DIAGRAMAS DE FLUJO ESTRUCTURADOS. 1. Estructura Secuencial: Es una estructura con una entrada y una salida en la cual figuran una serie de acciones cuya ejecución es lineal y en el orden en que aparecen, a la vez todas las acciones tienen una única entrada y salida. Figura 13. Estructura Secuencial 2. Estructura Alternativa: Es una estructura con una sola entrada y una sola salida en la cual se realiza una acción de entre varias, según una condición o se realiza un acción conforme a un cumplimiento o de una determinada condición. Esta condición puede ser simple o compuesta, existen dos tipos: De dos salidas en la que una de ellas puede ser la decisión nula; de tres o más salidas que también se llama múltiple. Figura 14. Estructura Alternativa 3. Estructura Repetitiva: Es una estructura con una entrada y una salida en la cual se repite una acción un numero determinado o indeterminado de veces, dependiendo en este caso del cumplimiento de una condición las estructuras repetitivas pueden ser tres: Estructura Para (FOR), Estructura Mientras (WHILE), Estructura (UNTIL). 4. Estructura Para (FOR): En una estructura se repite una acción un número 53 Ni := Si Ni A fijo de veces representado normalmente por N. Figura 15. Estructura FOR 5. Estructura Mientras (WHILE): En esta estructura se repite una acción mientras se cumpla la condición del bucle. La característica principal de esta estructura es la de que la condición es evaluada siempre antes de cada repetición. El número de repeticiones oscila entre cero e infinito, dependiendo de la evaluación de la condición, cuyos argumentos en los casos de repetición, al menos una vez, deberán modificarse dentro del bucle, de no ser así el número de repeticiones será infinito, y se formara un bucle sin salida. Figura 16. Estructura While. 6. Estructura Hasta (UNTIL): En esta estructura se repita una acción hasta que se cumpla la condición que controla el bucle, la cual se evalúa después de cada ejecución del mismo. El número de repeticiones oscila entre uno e infinito, dependiendo de la evaluación de la condición, cuyos argumentos en los casos de repetición, al menos dos veces, deberán modificarse dentro del bucle, de no ser así el bucle tendrá repeticiones infinitas y se formara un bucle sin salida. 54 Cond A Cond A Figura 17. Estructura Until 55 CAPITULO III HERRAMIENTAS A UTILIZAR 56 3.1 VISUAL C++ 6.0 PROFESIONAL Visual C++ esta contenido en el paquete de Visual Studio 6.0 Profesional de Microsoft y proporciona a los desarrolladores la licencia para distribuir programas desarrollados bajo esta herramienta, y tiene la ventaja sobre la Edición básica de añadir servicios y controles para plataformas Win32, incluyendo Windows 95/98 y Windows NT. El entorno de trabajo ha sido diseñado para brindar la mayor comodidad al usuario a la hora de generar sus aplicaciones, ver Figura 18. Figura 18. Entorno de trabajo en Visual C++ 6.0 Profesional. El compilador C++ incluye todos los archivos de cabecera, bibliotecas y editores de diálogo y de recursos necesarios para crear una aplicación en Windows verdaderamente consistente, ver Figura 19. Microsoft también ha incorporado los editores de recursos para mapas de BIT, iconos, cursores, menús y cuadros de diálogo, directamente integrados en el entorno. Y hablando de integración, la nueva clase de asistentes (ClassWizards) ayuda a construir aplicaciones OLE utilizando las bibliotecas MicrosoftFoundation CLass (MFÑ)en tiempo récord. 57 Figura 19. Ejecución de código fuente en C++ 6.0 Profesional 3.1.1 REQUERIMIENTOS DE RECURSOS. En cuanto a requerimientos de software y de hardware se recomienda el siguiente perfil de sistema para optimizar el ciclo de desarrollo de programas en C y C++. · PC con procesador Pentium, a velocidad de 200MHz (o superior). · 32 MB de RAM. · 1GB de espacio de disco fijo. · Monitor Super VGA. · Unidad de disco de alta densidad (3,5 pulgadas). · Unidad de CD-ROM (para documentación en línea). · Ratón lntelliPoint de Microsoft. Como podemos ver los requerimientos que esta herramienta necesita para utilizar su potencial son mínimos comparados con otras herramientas de desarrollo como el JDeveloper para Java. 58 Otro aspecto que se valoro a la hora de elegir la herramienta de desarrollo es que visual C++ 6.0 es compatible con Qt, insertando una barra de herramientas que permite combinar ambas herramientas de manera fácil, ver Figura 20. Figura 20. Barra de herramienta de integración con QT. La desventaja que presenta esta herramienta es el alto precio que se debe pagar por obtener todo el paquete de Visual Studio 6.0 Profesional, pero luego de ver lo que adquiere por dicho precio y las facilidades que representa a la hora de desarrollar una aplicación no se ve tanto como una desventaja sino como una inversión. 3.2 QT DESIGNER. Qt es una amplia plataforma de desarrollo que incluye clases, librerías y herramientas para la producción de aplicaciones de interfaz gráfica en C++ que pueden operar en varias plataformas. Con Qt se pueden desarrollar ricas aplicaciones gráficas, incluye soporte de nuevas tecnologías como OpenGL, XML, Bases de Datos, programación para redes, internacionalización y mucho más. Qt dispone de una amplia gama de herramientas que facilitan la creación de formas, botones y ventanas de dialogo con el uso del ratón. Las aplicaciones creadas con Qt son muy elegantes, se ven y se operan mejor que las aplicaciones nativas. Qt dispone de tres grandes ventajas ante las librerías de ventanas rivales: 59 1. Qt es completamente gratuito para aplicaciones de código abierto. 2. Las herramientas, librerías y clases están disponibles para casi todas las plataformas Unix y sus derivados (como Linux, MacOS X, Solaris, etc) como también para la familia Windows, por lo que una aplicación puede ser compilada y utilizada en cualquier plataforma sin necesidad de cambiar el código y la aplicación se verá y actuará como mejor que una aplicación nativa. 3. Qt tiene una extensa librería con clases y herramientas para la creación de ricas aplicaciones. Estas librerías y clases están bien documentadas, son muy fáciles de usar y tienen una gran herencia de programación orientada a objetos lo cual hace de la programación de interfaces gráficas verdaderamente cómoda. La nueva versión 4.2.2 permite la creación más fácil de ventanas a través de una interfaz grafica que permite dar formato de una manera más rápida que las versiones anteriores, ver Figura 21. Figura 21. Entorno de trabajo del QT Designer 4.2.2 El QT Designer permite generar el código C++ de toda la interfaz visual que se ha creado para manipular los eventos desde visual C++ 6.0 lo que facilita la integración de las aplicaciones. 60 3.3 MODULO QCANVAS. Para la interfaz grafica se utilizó el modulo QCanvas el cual es una clase que provee un área de gráficos en 2D sobre los cuales se pueden crear objetos llamados QCanvasItem. Un canvas conteniendo muchos objetos es muy diferente a los widgets conteniendo muchos subwidgets por las siguientes razones: • Los objetos son dibujados más rápidos que los widgets, en especial cuando no son rectangulares • Los objetos utilizan menos memoria que los widgets. • Encontrar los objetos dentro del área de dibuja es eficiente. • Se pueden crear muchas vistas para el mismo canvas. Figura 22. Ejemplos de figuras con canvas Los objetos que se crearon para este proyecto son los siguientes: - Para procesos: Clase principal: QCanvasRectangle. Clase heredada creada: c_proceso. Dimensiones: 150 x 50 píxeles. 61 - Para entradas desde el teclado (input): Clase principal: QCanvasPolygon Clase heredada creada: c_input. Dimensiones: 150 x 50 píxeles. - Para muestra de datos en pantalla (ouput): Clase principal: QCanvasPolygon Clase heredada creada: c_input. Dimensiones: 190 x 50 píxeles. - Para bucles o lazos (ciclo For y ciclo While) Para ciclo for: Clase principal: QCanvasPolygon Clase heredada creada: c_for. Dimensiones: 150 x 50 píxeles. Para ciclo while: Clase principal: QCanvasPolygon Clase heredada creada: c_while. Dimensiones: 150 x 50 píxeles. - Para decisiones (If) Clase principal: QCanvasPolygon Clase heredada creada: c_if. Dimensiones: 200 x 50 píxeles. 62 CAPITULO IV LA APLICACIÓN 63 4.1 REQUERIMIENTOS DEL SISTEMA El propósito de determinar los requerimientos es para tener una delimitación de la aplicación. Es la primera etapa en el desarrollo de un sistema, ya que en esta se especifican los datos que deben ser obtenidos del usuario y cuales deben ser procesados por la aplicación, así como determinar algunos requisitos que el usuario necesita para ejecutar la aplicación. 4.1.1 REQUERIMIENTOS PARA LA EJECUCION DEL SISTEMA La aplicación necesita ejecutarse sobre una estación que posea las siguientes aplicaciones: SOFTWARE • Sistema Operativo Microsoft Windows XP Professional Windows XP proporciona un nivel de estabilidad que permite la administración de manera eficiente los recursos del sistema, por lo que mantiene el sistema funcionando tan rápido como sea posible aún si se ejecutan múltiples aplicaciones simultáneamente. Para responder a fallos inesperados se cuenta con herramientas que permiten regresar el sistema a fechas previas en las que este se ejecutaba eficientemente. La aplicación puede correr en sistemas operativos mas recientes que Windows XP Professional. • qt-mt230nc.dll Es un archivo .dll que permite que Windows pueda correr aplicaciones elaboradas con la herramienta Qt-designer. HARDWARE Aquí se detallan los requerimientos mínimos para que la aplicación pueda correr en la estación de trabajo: • 64 MB de memoria RAM. • 700 Mhz de procesador ya sea Intel Celeron o superiores. • 20 MB de espacio libre en disco duro. 64 4.1.2 REQUERIMIENTOS DEL USUARIO Para el funcionamiento adecuado del sistema se requiere que el usuario especifique la información para la creación de los objetos dentro del diagrama a medida que este los va creando. A continuación se detalla el requerimiento por cada objeto: • Proceso: El usuario debe especificar las variables a utilizar ya sean de tipo Numérico, Carácter o Lógico. También se debe especificar las sentencias a realizar. Estas pueden ser utilizando funciones matemáticas o lógicas. • Petición de datos: El usuario debe seleccionar de las variables ya creadas cuales solicitara un valor por medio del teclado. • Muestra de datos: El usuario especificara el texto a mostrar. Dicho texto podrá contener el nombre de variables para mostrar su respectivo valor. • Ciclo While: El usuario debe introducir una condición teniendo en cuenta las reglas que rigen dicha sentencia y las variables creadas. • Ciclo For: El usuario debe introducir una condición teniendo en cuenta las reglas que rigen dicha sentencia y las variables creadas. • Decisión If: El usuario debe introducir una condición teniendo en cuenta las reglas que rigen dicha sentencia y las variables creadas. Luego de especificados los detalles de cada objeto el usuario deberá especificar la localización de los mismos dentro del diagrama hasta obtener el diseño deseado. 4.2 ANÁLISIS En esta etapa se procesan los requerimientos de la fase anterior, se depuran y se reestructuran para crear el cuerpo de aplicación y así poder pasar a la etapa de diseño de la aplicación. 65 4.2.1 TIPO DE INTÉRPRETE El sistema utiliza un Interprete Puro, recordando la definición de un interprete puro expone que un interprete puro es el que analiza y ejecuta sentencia por sentencia de todo el programa fuente. Para el caso del sistema, cuando se solicita ejecutar un diagrama, el intérprete hace un análisis de cada sentencia, si no se encuentra algún error entonces la sentencia se ejecuta. Para determinar si hubo algún error en la sentencia previo a la ejecución se hace un análisis léxico, sintáctico y semántico. 4.2.2 PROCESO DE INTERPRETACION. 4.2.2.1 DESCRIPCION GENERAL El proceso de interpretación se realiza de la siguiente forma: • Se toma el contenido del objeto según el orden de ejecución del diagrama. Dicho contenido se toma línea por línea para su respectivo análisis. • Se toma la línea y se le aplica el análisis léxico para identificar cada token que conforma dicha sentencia. Si no se encontró un error se prosigue con el análisis sintáctico, si se encontró se detiene el proceso de análisis y se muestra el respectivo mensaje de error. • Se realiza el análisis sintáctico para determinar si el orden de los tokens es el adecuado dentro de la sentencia. En caso de un error se detiene el análisis y se muestra el respectivo mensaje de error. • Se realiza análisis semántico en el cual se toma en si los operadores que se han encontrado se encuentran dentro de la tabla de símbolos y si los argumentos de las funciones son correctos de acuerdo al tipo de función y de acuerdo al tipo de dato. 66 • Si no se encontró ningún error, entonces se ejecuta la sentencia y se retoma la siguiente línea del objeto y se repite la fase de análisis y ejecución hasta que ya no hay más objetos que interpretar. 4.2.2.2 TABLA DE SIMBOLOS La tabla de símbolos es la que contiene