ipl-logo

Manualtecnico

.pdf
School
Instituto Politecnico National Escuela Superior de**We aren't endorsed by this school
Course
PROGRAMACI 221
Subject
Computer Science
Date
Jan 5, 2025
Pages
16
Uploaded by KidMole6829
INTRODUCCIÓNLogo es un lenguaje de programación diseñado específicamente para facilitar la enseñanza de conceptos informáticos. Desarrollado en los años 60, este lenguaje se centra en proporcionar una experiencia de aprendizaje interactiva y visual, permitiendo a los usuarios manipular una figura gráfica conocida como "tortuga". Este enfoque no solo introduce a los estudiantes a la lógica de programación, sino que también fomenta la creatividad a través del dibujo de formas y patrones.En un entorno educativo, Logo se destaca por su capacidad para simplificar conceptos complejos de programación y matemáticas, haciendo que el aprendizaje sea accesible y atractivo para los principiantes. Los comandos básicos permiten controlar el movimiento y las acciones de la tortuga, lo que ayuda a los usuarios a comprender de manera práctica principios como la secuenciación, la repetición y la modularidad.OBJETIVOEl propósito de este trabajo es proporcionar una guía técnica detallada del proyecto, diseñada para ser comprensible por profesionales con conocimientos técnicos adecuados. Esto permitirá que el software pueda ser modificado, mejorado y adaptado según las necesidades futuras. Al ofrecer una documentación exhaustiva, se facilita la comprensión del diseño y la arquitectura del sistema, promoviendo así un mantenimiento eficaz y la posibilidad de futuras expansiones o integraciones con otras tecnologías. Esta referencia servirá como base sólida para cualquier acción que se desee realizar en el software, asegurando su evolución continua y optimización.REQUERIMIENTOS TÉCNICOSJava: Plataforma informática lanzada en 1995 por Sun Microsystems, esencial para muchas aplicaciones y sitios web. Java es reconocido por su rapidez, seguridad y viabilidad, siendo fundamental para una amplia gama de dispositivos, desde portátiles hasta supercomputadoras. Sirve como base para el desarrollo de aplicaciones de red, móviles, embebidas, juegos, y software empresarial, facilitando la creación y distribución eficiente de contenidos y servicios.Java Development Kit (JDK): Conjunto de herramientas esenciales para desarrollar, probar y ejecutar aplicaciones, applets y componentes en Java. El JDK proporciona un entorno completo de desarrollo, incluyendo compiladores, bibliotecas y utilidades necesarias para la creación de programas Java, garantizando un flujo de trabajo optimizado para los desarrolladores.Java Runtime Environment (JRE): Parte fundamental del software Java que se descarga e instala para ejecutar aplicaciones. El JRE incluye la Java Virtual Machine (JVM), clases centrales y bibliotecas de soporte, proporcionando el entorno necesario para la ejecución de aplicaciones Java en navegadores web y sistemas operativos.
Background image
BYACC: Un compilador para el lenguaje YACC, adaptado específicamente para el desarrollo en Java. BYACC permite la generación eficiente de analizadores sintácticos, facilitando el manejo de gramáticas complejas y mejorando la funcionalidad del software.IntelliJ IDEA: Un entorno de desarrollo integrado (IDE) robusto y versátil, ideal para manejar proyectos en Java. IntelliJ IDEA ofrece características avanzadas como autocompletado de código, depuración integrada, herramientas de refactorización y soporte para diversos frameworks, lo que potencia la productividad del desarrollador y mejora la calidad del código del proyecto.EJECUCIONPara comenzar, asegurarse de tener IntelliJ IDEA instalado en el sistema. Una vez instalado, se busca y abre el IDE desde el escritorio. Al iniciarlo, se mostrará la pantalla principal con diversas opciones. Selecciona "Open Project" para acceder al proyecto y empezar a trabajar en él.Figura 1. Abrir proyecto. Fuente: Propia.Página | 1
Background image
Ahora procederemos a ejecutar el programa esto lo lograremos abriendo el archivo de SuUnidad\Proyecto\proyecto\Código Fuente\src\Logos\Logos.java.Figura 2. Archivo para correr el programa. Fuente: Propia.Después en la parte superior de la aplicación IntelliJ IDEA corremos el programa desplegando el Proyecto Logos, como se puede ver en la Figura 3.Figura 3. Desplegar programa. Fuente: Propia.Desplegándose de la siguiente manera, Figura 4:Página | 2
Background image
Figura 4. Programa desplegado. Fuente: Propia.Una vez que se ejecuta el programa tendremos la interfaz gráfica mostrada en la Figura 4, en donde tenemos los siguientes componentes: Un área de texto dedicada a la entrada de comandos del lenguaje es fundamental, ya que aquí se introducen todas las instrucciones necesarias para crear las figuras y patrones deseados. Este componente permite a los usuarios especificar de manera precisa cada comando, facilitando la personalización y complejidad de los diseños según los requisitos del proyecto. Es el punto de partida para toda la interacción con el programa, permitiendo un control total sobre las acciones que se visualizarán en el panel de dibujo. Botón para ejecutar comandos: Este botón es esencial para transformar las instrucciones escritas en el área de texto en acciones visuales en el panel de dibujo.Botón para borrar el panel: Este botón permite limpiar el panel de visualización, eliminando los dibujos actuales. Además, si se presiona nuevamente después de ser activado, restaura el estado previo, deshabilitando la opción de dibujo paso a paso y preservando cualquier modificación realizada hasta ese momento.Botón para dibujo paso a paso: Este botón ofrece la posibilidad de visualizar el proceso de dibujo de manera incremental. Al activar esta función, los usuarios pueden observar cómo se construye la figura en etapas, lo que es útil para entender la secuencia de comandos y depurar el proceso. Panel de visualización: Este es el espacio donde se muestran los resultados de los comandos ingresados. Actúa como un lienzo, permitiendo a los usuarios ver las figuras y patrones generados, brindando una representación gráfica del código ejecutado.Página | 3
Background image
EXPRESIONES REGULARESLas expresiones regulares definidas a continuación son fundamentales para generar patrones y diseños dentro del programa. Cada expresión permite controlar el comportamiento de las figuras y personalizar los resultados visuales:FORWARD[double]: Mueve la "tortuga" una distancia específica, facilitando la creación de líneas y formas.TURN[double]: Gira la "tortuga" en un ángulo determinado, permitiendo cambios de dirección precisos.COLOR[double, double, double]: Define el color utilizando valores RGB, personalizando la apariencia de los dibujos.PenUP[]: Levanta el "lápiz" para mover la tortuga sin dejar rastro en el panel.PenDOWN[]: Baja el "lápiz", habilitando la creación de trazos en el panel.for(inicialización; condición; expresión final){}: Bucle para repetir un bloque de instrucciones un número específico de veces, útil para patrones iterativos.while(condición){declaración(es)}: Bucle que ejecuta instrucciones mientras se cumple una condición, adecuado para operaciones repetitivas basadas en criterios dinámicos.if(condición){instrucciones}else{instrucciones}: Estructura de control que ejecuta diferentes bloques de instrucciones según la evaluación de una condición.Para definir procedimientos y funciones:proc [nombre](){Bloque de instrucciones}: Define un procedimiento que encapsula un conjunto de instrucciones. Los parámetros se indican con `$n`.func [nombre](){ Bloque de instrucciones return valor; }: Define una función que realiza operaciones y devuelve un valor. Los parámetros también se utilizan con `$n`.Las condiciones disponibles, como `==`, `!=`, `<=`, `>`, `>=`, `&&`, y `||`, permiten construir expresiones lógicas complejas, facilitando la creación de patrones sofisticados y dinámicos.Página | 4
Background image
GRAMATICA%token IF%token ELSE%token WHILE%token FOR%token COMP%token DIFERENTES%token MAY%token MEN%token MAYI%token MENI%token FNCT%token NUMBER%token VAR%token AND%token OR%token FUNC%token RETURN%token PARAMETRO%token PROC%right '='%left '+' '-'%left '*' '/'%left ';'%left COMP%left DIFERENTES%left MAY%left MAYI%left MEN%left MENI%left '!'%left AND%left OR%right RETURN%%list: | list'\n'| listlinea'\n';linea: exp';' {$$ = $1;}|stmt{$$ = $1;}|lineaexp';' {$$ = $1;}|lineastmt{$$ = $1;};
Background image
exp: VAR{ $$ = new ParserVal(maquina.agregarOperacion("varPush_Eval")); maquina.agregar($1.sval);}|'-' exp{$$ = new ParserVal(maquina.agregarOperacion("negativo"));}|NUMBER{$$ = new ParserVal(maquina.agregarOperacion("constPush"));maquina.agregar($1.dval);}| VAR'=' exp{$$ = new ParserVal($3.ival);maquina.agregarOperacion("varPush");maquina.agregar($1.sval);maquina.agregarOperacion("asignar");maquina.agregarOperacion("varPush_Eval"); maquina.agregar($1.sval);}| exp'*' exp{$$ = new ParserVal($1.ival);maquina.agregarOperacion("MUL");}| exp'/' exp{$$ = new ParserVal($1.ival);maquina.agregarOperacion("DIV");}| exp'+' exp{$$ = new ParserVal($1.ival);maquina.agregarOperacion("SUM");}| exp'-' exp{$$ = new ParserVal($1.ival);maquina.agregarOperacion("RES");}|'(' exp')' {$$ = new ParserVal($2.ival);}| expCOMPexp{maquina.agregarOperacion("EQ");$$ = $1;}| expDIFERENTESexp{maquina.agregarOperacion("NE");$$ = $1;}| expMENexp{maquina.agregarOperacion("LE");$$ = $1;
Background image
}| expMENIexp{maquina.agregarOperacion("LQ");$$ = $1;}| expMAYexp{maquina.agregarOperacion("GR");$$ = $1;}| expMAYIexp{maquina.agregarOperacion("GE");$$ = $1;}| expANDexp{maquina.agregarOperacion("AND");$$ = $1;}| expORexp{maquina.agregarOperacion("OR");$$ = $1;}| '!' exp{maquina.agregarOperacion("NOT");$$ = $2;}| RETURNexp{ $$ = $2; maquina.agregarOperacion("_return"); } | PARAMETRO{ $$ = new ParserVal(maquina.agregarOperacion("push_parametro")); maquina.agregar((int)$1.ival); }|nombreProc'(' arglist')' { $$ = new ParserVal(maquina.agregarOperacionEn("invocar",($1.ival))); maquina.agregar(null); } //instrucciones tiene la estructura necesaria para la lista de argumentos;arglist: |exp{$$ = $1; maquina.agregar("Limite");}|arglist',' exp{$$ = $1; maquina.agregar("Limite");};nop: {$$ = new ParserVal(maquina.agregarOperacion("nop"));};stmt:if'(' expstop')' '{' lineastop'}' ELSE'{' lineastop'}' {$$ = $1;maquina.agregar($7.ival, $1.ival + 1);maquina.agregar($12.ival, $1.ival + 2);maquina.agregar(maquina.numeroDeElementos() - 1, $1.ival + 3);}
Background image
| if'(' expstop')' '{' lineastop'}' nopstop{$$ = $1;maquina.agregar($7.ival, $1.ival + 1);maquina.agregar($10.ival, $1.ival + 2);maquina.agregar(maquina.numeroDeElementos() - 1, $1.ival + 3);}| while'(' expstop')' '{' lineastop'}' stop{$$ = $1;maquina.agregar($7.ival, $1.ival + 1);maquina.agregar($10.ival, $1.ival + 2);}| for'(' instruccionesstop';' expstop';' instruccionesstop')' '{' lineastop'}' stop{$$ = $1;maquina.agregar($6.ival, $1.ival + 1);maquina.agregar($9.ival, $1.ival + 2);maquina.agregar($13.ival, $1.ival + 3);maquina.agregar($16.ival, $1.ival + 4);}| funcionnombreProc'(' ')' '{' lineanull'}'| procedimientonombreProc'(' ')' '{' lineanull'}'| instruccion'[' arglist']' ';' { $$ = new ParserVal($1.ival);maquina.agregar(null);};instruccion: FNCT{$$ = new ParserVal(maquina.agregar((Funcion)($1.obj)));};procedimiento: PROC{ maquina.agregarOperacion("declaracion"); };funcion: FUNC{ maquina.agregarOperacion("declaracion"); };nombreProc: VAR{$$ = new ParserVal(maquina.agregar($1.sval));};null: {maquina.agregar(null);};stop: {$$ = new ParserVal(maquina.agregarOperacion("stop"));} ;if: IF{$$ = new ParserVal(maquina.agregarOperacion("IF_ELSE"));maquina.agregarOperacion("stop");//thenmaquina.agregarOperacion("stop");//else
Background image
maquina.agregarOperacion("stop");//siguiente comando};while: WHILE{$$ = new ParserVal(maquina.agregarOperacion("WHILE"));maquina.agregarOperacion("stop");//cuerpomaquina.agregarOperacion("stop");//final};for: FOR{$$ = new ParserVal(maquina.agregarOperacion("FOR"));maquina.agregarOperacion("stop");//condicionmaquina.agregarOperacion("stop");//instrucción finalmaquina.agregarOperacion("stop");//cuerpomaquina.agregarOperacion("stop");//final} instrucciones: { $$ = new ParserVal(maquina.agregarOperacion("nop"));}|exp{$$ = $1;}|instrucciones',' exp{$$ = $1;};%%Página | 10
Background image
EXPLICACIÓN ACERCA DE CREACIÓNPara llevar a cabo este proyecto, se integraron todos los conocimientos adquiridos a lo largo del curso. En primer lugar, se desarrolló una clase denominada "Par", similar a las utilizadas en prácticas anteriores, que asocia un nombre con un objeto. Esta clase es fundamental para la estructura de datos que emplearemos.En segundo lugar, se creó una tabla de símbolos que almacena todas las instrucciones necesarias, como TURN, FORWARD, COLOR, PenUP y PenDOWN. Esta tabla actúa como un repositorio central donde se definen y manejan las funcionalidades del programa, permitiendo la interpretación y ejecución de los comandos.Además, se implementó una máquina de pila, contenida en un archivo Java del mismo nombre, que es crucial para el funcionamiento del proyecto. Esta máquina es responsable de gestionar las condiciones y operaciones lógicas, así como de ejecutar las instrucciones definidas en la tabla de símbolos. Su diseño permite un manejo eficiente de los comandos y asegura que las operaciones se realicen correctamente, formando el núcleo operativo del sistema. El código de la máquina de pila integra los aspectos lógicos y operativos del proyecto, proporcionando una base sólida sobre la cual se construyen las funcionalidades avanzadas, asegurando un flujo de trabajo coherente y efectivo.private void declaracion(){tabla.insertar((String)memoria.get(++contadorDePrograma), ++contadorDePrograma); //Apuntamos a la primera instrucción de la funciónint invocados = 0;while(memoria.get(contadorDePrograma) != null || invocados != 0){ //Llevamos cp hasta la siguiente instrucción después de la declaraciónif( memoria.get(contadorDePrograma) instanceof Method)if(((Method)memoria.get(contadorDePrograma)).getName().equals("invocar"))invocados++;if( memoria.get(contadorDePrograma) instanceof Funcion)invocados++;if(memoria.get(contadorDePrograma) == null)invocados--;contadorDePrograma++;}}private void invocar(){ Marco marco = new Marco();String nombre = (String)memoria.get(++contadorDePrograma);marco.setNombre(nombre);contadorDePrograma++;while(memoria.get(contadorDePrograma) != null){ //Aquí también usamos null como delimitador. Aquí se agregan los parámetros al marcoif(memoria.get(contadorDePrograma) instanceof String){
Background image
if(((String)(memoria.get(contadorDePrograma))).equals("Limite")){Object parametro = pila.pop();marco.agregarParametro(parametro);contadorDePrograma++;}}else{ ejecutarInstruccion(contadorDePrograma);}}marco.setRetorno(contadorDePrograma);pilaDeMarcos.add(marco);ejecutarFuncion((int)tabla.encontrar(nombre)); //VAMOS AQUI***************************}private void push_parametro(){pila.push(pilaDeMarcos.lastElement().getParametro((int)memoria.get(++contadorDePrograma)-1));}//Métodos para la ejecuciónpublic void imprimirMemoria(){for(int i = 0; i < memoria.size(); i++)System.out.println("" + i + ": " +memoria.get(i));}public void ejecutar(){//imprimirMemoria();stop = false;while(contadorDePrograma < memoria.size())ejecutarInstruccion(contadorDePrograma);}public boolean ejecutarSiguiente(){//imprimirMemoria();if(contadorDePrograma < memoria.size()){ejecutarInstruccion(contadorDePrograma);return true;}return false;}public void ejecutar(int indice){//ejecuta hasta que se encuentra Stop contadorDePrograma = indice;while(!stop && !returning){ejecutarInstruccion(contadorDePrograma);
Background image
}stop = false;}public void ejecutarFuncion(int indice){ contadorDePrograma = indice;while(!returning && memoria.get(contadorDePrograma) != null){ejecutarInstruccion(contadorDePrograma);}returning = false;contadorDePrograma = pilaDeMarcos.lastElement().getRetorno();pilaDeMarcos.removeElement(pilaDeMarcos.lastElement());}public void ejecutarInstruccion(int indice){//System.out.println("Ejecutando: " + indice);try{ Object objetoLeido = memoria.get(indice);if(objetoLeido instanceof Method){Method metodo = (Method)objetoLeido;metodo.invoke(this, null);}if(objetoLeido instanceof Funcion){ArrayList parametros = new ArrayList();Funcion funcion = (Funcion)objetoLeido;contadorDePrograma++;while(memoria.get(contadorDePrograma) != null){ //Aquí también usamos null como delimitador. Aquí se agregan los parámetros al marcoif(memoria.get(contadorDePrograma) instanceof String){if(((String)(memoria.get(contadorDePrograma))).equals("Limite")){Object parametro = pila.pop();parametros.add(parametro);contadorDePrograma++;}}else{ ejecutarInstruccion(contadorDePrograma);}}funcion.ejecutar(configuracionActual, parametros);}contadorDePrograma++;}catch(Exception e){}}public Configuracion getConfiguracion(){
Background image
return configuracionActual;}public static class Girar implements Funcion{@Overridepublic void ejecutar(Object A, ArrayList parametros) {Configuracion configuracion = (Configuracion)A;int angulo = (configuracion.getAngulo() + (int)(double)parametros.get(0))%360;configuracion.setAngulo(angulo);}}public static class Avanzar implements Funcion{@Overridepublic void ejecutar(Object A, ArrayList parametros) {Configuracion configuracion = (Configuracion)A;int angulo = configuracion.getAngulo();double x0 = configuracion.getX();double y0 = configuracion.getY();double x1 = x0 + Math.cos(Math.toRadians(angulo))*(double)parametros.get(0);double y1 = y0 + Math.sin(Math.toRadians(angulo))*(double)parametros.get(0);configuracion.setPosicion(x1, y1);configuracion.agregarLinea(new Linea((int)x0,(int)y0,(int)x1,(int)y1, configuracion.getColor()));}}public static class CambiarColor implements Funcion{@Overridepublic void ejecutar(Object A, ArrayList parametros) {Configuracion configuracion = (Configuracion)A;configuracion.setColor(new Color((int)(double)parametros.get(0)%256, (int)(double)parametros.get(1)%256, (int)(double)parametros.get(2)%256));}}public static class SubirPincel implements Funcion{@Overridepublic void ejecutar(Object A, ArrayList parametros) {Configuracion configuracion = (Configuracion)A;configuracion.setColor(Color.GRAY);}}public static class BajarPincel implements Funcion{@Overridepublic void ejecutar(Object A, ArrayList parametros) {
Background image
Configuracion configuracion = (Configuracion)A;configuracion.setColor(Color.BLACK);}}}Página | 14
Background image
En los anteriores fragmentos de código se encuentran los componentes más cruciales de nuestro proyecto, pues aquí se define y se controla el comportamiento durante la ejecución. Para agregar nuevas funcionalidades al proyecto, es fundamental modificar estos fragmentos y el archivo P2.y, reflejando los cambios en Parser y ParserVal que se generan al compilar el archivo YACC. Además, es importante recordar que utilizamos Marcos para estructurar nuestro código.Toda la funcionalidad del proyecto se basa en Java, pero este funcionamiento depende en gran medida de nuestro archivo YACC, donde se define la gramática. En este archivo, invocamos las funciones creadas en nuestra máquina de pila, asignamos caracteres reservados a las funciones previamente definidas, todo esto en nuestro yylex. Finalmente, se añade funcionalidad a los botones en la interfaz gráfica de usuario (GUI).La GUI juega un papel crucial en la interacción con el usuario. En el archivo Configuracion.java, se guarda el historial de líneas dibujadas mediante un ArrayList, utilizando la clase Linea.java para cambiar el color, definir la dirección y tamaño de las líneas. Configuracion.java también facilita la visualización de estas líneas. Para representar gráficamente las operaciones del usuario, se utiliza PanelDeDibujo.java, donde se dibuja un triángulo que indica la dirección de la próxima acción de dibujo.Finalmente, tenemos VentanaPrincipal.java y Logos.java. En VentanaPrincipal.java, se definen y organizan los componentes con los que el usuario interactuará, asegurando una presentación coherente y funcional. Logos.java se encarga de la ejecución del programa, integrando todos los elementos en un flujo de trabajo cohesivo y eficiente.Estos componentes, en conjunto, forman el núcleo del proyecto, permitiendo una experiencia de usuario intuitiva y funcional, y facilitando futuras expansiones y mejoras del sistema.Página | 15
Background image