Informe - Escuela de Ingeniería Eléctrica

Universidad de Costa Rica
Facultad de Ingeniería
Escuela de Ingeniería Eléctrica
IE – 0502 Proyecto Eléctrico
GENERACION DE UNA INTERFAZ DE
VISUALIZACION PARA UN SIMULADOR
PARA LA CPUCR
Por:
Jairo Alberto Roldán Morales
Ciudad Universitaria Rodrigo Facio
Julio del 2009
GENERACION DE UNA INTERFAZ DE
VISUALIZACION PARA UN SIMULADOR
PARA LA CPUCR
Por:
Jairo Alberto Roldán Morales
Sometido a la Escuela de Ingeniería Eléctrica
de la Facultad de Ingeniería
de la Universidad de Costa Rica
como requisito parcial para optar por el grado de:
BACHILLER EN INGENIERÍA ELÉCTRICA
Aprobado por el Tribunal:
_________________________________
Ing. Roberto Rodríguez Rodríguez
Profesor Guía
_________________________________
Ing. José Freddy Rojas Chavarría
Profesor lector
_________________________________
Ing. Andrés Díaz Soto
Profesor lector
i
DEDICATORIA
A Dios primeramente, a él sea la gloria por todas las bendiciones que me ha dado por su
infinita gracia, a mis padres por la comprensión, paciencia y apoyo brindado en este difícil
camino y a mi novia por apoyarme y alentarme durante todo este tiempo.
ii
RECONOCIMIENTOS
A todos mis profesores, compañeros, amigos, a mi novia y demás personas que han
compartido conmigo sus conocimientos y me han enseñado muchas cosas. A mis padres
por la formación que me han dado, pues han hecho de mí la persona que soy, y a Dios, que
me permite levantarme todos los días con una razón y una esperanza para cada día.
iii
ÍNDICE GENERAL
ÍNDICE GENERAL ......................................................................................................... iv
ÍNDICE DE FIGURAS..................................................................................................... vi
ÍNDICE DE CUADROS .................................................................................................. vii
NOMENCLATURA ....................................................................................................... viii
RESUMEN....................................................................................................................... ix
CAPITULO 1: Introducción............................................................................................... 1
1.1 Objetivos.................................................................................................................. 2
Objetivo general ......................................................................................... 2
1.1.1
Objetivos específicos .................................................................................. 2
1.1.2
1.2 Metodología ............................................................................................................. 3
CAPITULO 2: Desarrollo teórico....................................................................................... 5
2.1 Interfaz Gráfica de Usuario....................................................................................... 5
2.2 Programación Orientada A Objetos (P.O.O.) ............................................................ 6
Conceptos fundamentales............................................................................ 7
2.2.1
2.3 CPUCR_2 (8 Bits).................................................................................................. 10
Código de Instrucción ............................................................................... 10
2.3.1
Modos de Direccionamiento ..................................................................... 11
2.3.2
Instrucciones............................................................................................. 12
2.3.3
2.4 CPUCR_3 (32 Bits)................................................................................................ 13
Código de Instrucción ............................................................................... 13
2.4.1
Modo de Direccionamiento....................................................................... 14
2.4.2
Instrucciones............................................................................................. 15
2.4.3
2.5 GTK+..................................................................................................................... 17
Bibliotecas de GTK+ ................................................................................ 18
2.5.1
Widgets y Objetos más comunes de GTK+2.0 .......................................... 20
2.5.2
CAPITULO 3: Diseño de la Interfaz Gráfica.................................................................... 22
3.1 Archivo principal del programa (main) ................................................................... 23
3.2 Ventana del Editor de Texto ................................................................................... 29
3.3 Ventana de Registros.............................................................................................. 33
3.4 Ventana de Memoria .............................................................................................. 36
CAPITULO 4: Interfaz de Compilación y Simulación...................................................... 42
CAPITULO 5: Conclusiones y Recomendaciones............................................................ 52
Conclusiones:............................................................................................................... 52
Recomendaciones: ....................................................................................................... 53
CAPITULO 6: BIBLIOGRAFÍA ..................................................................................... 53
APÉNDICES ................................................................................................................... 55
Archivo Makefile para la interfaz gráfica con el compilador y el simulador .............. 55
Archivo Makefile para el compilador y simulador..................................................... 56
Archivo Editor.h ...................................................................................................... 57
Archivo Interfaz.h .................................................................................................... 58
Archivo Registros.h.................................................................................................. 61
iv
Archivo main.cpp..................................................................................................... 63
Archivo Editor.cpp................................................................................................... 92
Archivo Interfaz.cpp............................................................................................... 101
Archivo Registros.cpp ............................................................................................ 115
ANEXOS....................................................................................................................... 159
v
ÍNDICE DE FIGURAS
Figura 2.1: Ejemplo de Interfaz Gráfica (GNU/Linux) ....................................................... 5
Figura 2.2: Codificación de una instrucción de la CPUCR_2 [12] ....................................... 11
Figura 2.3: Organización de las Instrucciones de la CPUCR_3......................................... 14
Figura 2.4: Emblema de GTK [8] ...................................................................................... 17
Figura 3.1: Interacción de los módulos de la Interfaz Gráfica .......................................... 23
Figura 3.2: Ventana tipo diálogo que muestra los créditos................................................ 24
Figura 3.3: Ventana de confirmación para salir ................................................................ 24
Figura 3.4: Asistente para guardar un archivo................................................................... 25
Figura 3.5: Asistente para la apertura de un archivo ......................................................... 26
Figura 3.6: Mensaje de error pre-ejecución....................................................................... 28
Figura 3.7: Ventana Principal, Editor de Texto................................................................. 29
Figura 3.8: Ventana de Registros...................................................................................... 33
Figura 3.9: Distribución de contenedores para la ventana de registros .............................. 34
Figura 3.10: Ventana de memoria..................................................................................... 37
Figura 4.1: Captura obtenida del resultado de la primera prueba....................................... 44
Figura 4.2: Captura obtenida del resultado de la primera prueba....................................... 45
Figura 4.3: Prueba al botón "Detener en".......................................................................... 45
Figura 4.4: Ejemplo de simulación ................................................................................... 46
Figura 4.5: Registros obtenidos en simulación de prueba.................................................. 47
Figura 4.6: Ventana de memoria en simulación de prueba ................................................ 48
Figura 4.7: Ventana de registros de simulación hasta posición específica de memoria. ..... 50
Figura 4.8: Prueba de simulación paso a paso................................................................... 51
vi
ÍNDICE DE CUADROS
Cuadro 2.1 Modos de direccionamiento de la CPUCR_2 [12] ............................................. 11
Cuadro 2.2: Casos especiales de direccionamiento en la CPUCR_2 [12]............................. 12
Cuadro 2.3: Instrucciones de la CPUCR_2 [12] .................................................................. 12
Cuadro 2.4: Modos de direccionamiento CPUCR_3 [12].................................................... 14
Cuadro 2.5: Instrucciones de la CPUCR_3 [12] ................................................................. 16
Cuadro 3.1: Atributos aplicados a la sintaxis .................................................................... 31
Cuadro 4.1: Primer código introducido para la sección de pruebas ................................... 43
Cuadro 4.2: Segundo código introducido para la sección de pruebas ................................ 44
Cuadro 4.3: Ventana de memoria del ejemplo de simulación............................................ 49
vii
NOMENCLATURA
P.O.O.
Programa Orientado a Objetos
GTK
Gimp Tool Kit
GUI
Graphical User Interface
GNOME
GNU Network Object Model Environment
Xfce
XForms Common Enviroment
Qt
Biblioteca multiplataforma para desarrollar interfaces gráficas de
usuario
CPUCR
Procesador de computadora diseñado en sus distintas versiones por
profesores y estudiantes de la Universidad de Costa Rica
viii
RESUMEN
El principal objetivo que llevó a la realización de este proyecto es la necesidad de
tener una interfaz gráfica de visualización para las últimas versiones de la CPUCR, la cual
permite al usuario de manera sencilla compilar, mostrar y manipular los parámetros de la
simulación. Para ello se utilizó el lenguaje de programación C++ con librerías de GTK+2.0.
Lo primero que se hizo fue estudiar las principales características de las versiones
de la CPUCR de 8 bits y de 32 bits, de igual manera, fue necesario estudiar la sintaxis,
orden y procedimientos necesarios para poder programar en C++ con librerías de GTK+2.0.
Para la elaboración del programa, se inició creando un editor de texto desde el cual
el usuario ingrese el código fuente, este editor tiene funciones básicas como copiar, pegar,
abrir, guardar, compilar y ejecutar el programa, entre otras. Además, al editor se le agregó
la característica de resaltar la sintaxis en tiempo real, y es desde el editor que el usuario
selecciona la versión de la CPUCR que se desea simular.
Seguidamente, se creó la ventana de registros, que muestra al usuario los registros
del procesador para las distintas versiones de la CPUCR y le permite modificarlos.
Además, es desde aquí que el usuario puede acceder a la ventana de memoria, la cual
provee características como visualizar posiciones de memoria específicas, ejecutar hasta
una posición de memoria o ejecutar paso a paso la simulación.
Finalmente, se procedió a unir la interfaz gráfica con un compilador a través de un
objeto, lo cual resultó de manera exitosa, además, el programa quedó previsto para unirlo
con un simulador, de tal manera que la interfaz gráfica este permanentemente conectada
con el compilador y con el simulador.
ix
CAPITULO 1: Introducción
Este proyecto tiene como principal objetivo, crear una interfaz de visualización para
la CPUCR, en donde se puedan modificar las variables de simulación, así como facilitar al
usuario la simulación de un programa y su interpretación.
El proyecto nace como una necesidad, pues la versión de la CPUCR utilizada hasta
ahora para el curso Estructuras de Computadoras no es la más reciente (CPUCR de 6 bits).
Además, los procesadores actuales presentan nuevas y mejoradas características, por lo que
se hace necesario utilizar un procesador con más reciente, tales como la CPUCR de 8 bits y
32 bits, que ya existen teóricamente pero no tienen programas capaces de realizar
simulaciones. De ahí la necesidad de este proyecto: crear una interfaz gráfica para la
simulación y ejecución de programas para la CPUCR.
La metodología a utilizar para la elaboración de este proyecto está relacionada
directamente con lenguajes de programación como es el caso de C, C++ con librerías
GTK+2.0, cabe resaltar que el proyecto se realiza para la plataforma GNU/Linux, aunque
puede ser funcional también para Microsoft Windows si se instalan los paquetes requeridos
por el programa.
1
2
1.1
Objetivos
1.1.1 Objetivo general
•
Generar una interfaz de visualización para un simulador para la CPUCR
1.1.2 Objetivos específicos
•
Generar una interfaz de simulación para la CPUCR que permita de una forma
simple cambiar de una versión de la CPUCR a otra.
•
Construir una interfaz para la comunicación del sistema de visualización con un
sistema ensamblador-simulador tal que permita el control del sistema y modificar
variables de la simulación como son los registros del procesador y posiciones de la
memoria.
•
Incluir en el sistema funcionalidades que permitan simular paso a paso, hasta que se
de la instrucción de detenerse o hasta un punto indicado.
•
Agregar funcionalidades al sistema de visualización tal que permita mostrar
registros, cambiarlos, listar variables, posiciones de memoria específicas y otras que
posee el EMU8086a.
a
El EMU8086 es una interfaz gráfica que fue diseñada para emular el comportamiento del procesador Intel
8086
3
1.2
Metodología
La metodología a seguir para la elaboración de este proyecto, se puede dividir en 5
grandes etapas: estudio preeliminar, elaboración del programa, etapa de depuración, unión
de la interfaz gráfica con el compilador y simulador y elaboración del informe final.
1. Estudio preeliminar: fue necesario estudiar los conceptos básicos de la
programación orientada a objetos (P.O.O.), esto porque se iba a utilizar este tipo de
programación en la elaboración del programa. También fue necesario estudiar a
fondo las versiones de la CPUCR, pues es indispensable conocer detalladamente lo
que se pretende simular. Finalmente, se analizó el funcionamiento del EMU8086,
pues se deseaba que el simulador para la CPUCR tuviera muchas de las
funcionalidades que tiene este simulador, además, este emulador EMU8086 es un
ejemplo real de lo que se deseaba hacer.
2. Elaboración del programa: comienza con la instalación de paquetes necesarios para
poder compilar y ejecutar adecuadamente un programa en GNU/Linux y en
Microsoft Windows, luego, se hicieron distintos “mini-programas” en donde cada
uno presentaba una funcionalidad diferente, como barras de menú, barras de
herramientas, cuadros y ventanas de texto, botones, etiquetas, cajas y otros widgetsb
presentes en el programa final, en el que se unieron estos “mini-programas” para
formar un conjunto (esto se hizo uniendo las porciones de código de cada miniprograma, de tal manera que al final se obtiene un conjunto). Dicha unión se hizo de
manera estructurada para cada módulo (una porción de código de gran extensión,
continua y ordenada para cada módulo, con gran cantidad de información, funciones
4
y variables) y cada módulo unido con los otros módulos a través de un objeto, lo
cual representa la totalidad del programa.
3. Etapa de depuración: una vez que el programa presentaba una funcionalidad
aceptable, se procedió a corregir aquellos aspectos del programa que podían
desembocar en un cierre inesperado del programa o un indebido funcionamiento del
mismo. Esto se consiguió estudiando detalladamente la sintaxis de cada instrucción
y mejorando los aspectos que se creyeron pertinentes. Se revisaron también otras
porciones de código y se eliminaron aquellas que resultaron innecesarias.
4. Unión de la interfaz gráfica con el compilador y el simulador: esta unión se llevó a
cabo en manera conjunta con el creador de el compilador y simulador, el estudiante
Edgar Villalobos Ortega, con quien antes de la elaboración de los programas
(interfaz gráfica, compilador y simulador) se dialogó y se había llegado a un común
acuerdo para la manera en que se iban a comunicar dichos programas. Esta unión se
haría por medio de objetos, cuyos argumentos iban a ser de tipo string, lo cual
resultó de manera exitosa y no presentó inconvenientes o incompatibilidad entre las
partes.
5. Elaboración del informe final: el informe se hizo incluyendo los objetivos del
proyecto y la información teórica más relevante También se explica el
procedimiento que se utilizó para crear la interfaz gráfica y unirla con el compilador
y simlador. Se incluye además el código fuente del programa completo, las
conclusiones y recomendaciones que se obtuvieron al finalizar el proyecto.
b
El significado de Widget se explicará más adelante en la página 20.
CAPITULO 2: Desarrollo teórico
Para comprender muchos detalles y conceptos que se utilizan en este proyecto, es
necesario saber primero que son y de que tratan estos conceptos. Algunos de ellos son: la
interfaz gráfica de usuario, las bibliotecas GTK, el procesador CPUCR de 8 bits y de 32
bits, entre otros.
2.1 Interfaz Gráfica de Usuario
La interfaz gráfica de usuario (en idioma inglés Graphical User Interface
[2]
, GUI)
es una aplicación gráfica que permite al usuario interactuar de una manera sencilla con un
programa de computadora.
La interfaz gráfica de usuario es un tipo de interfaz de usuario que utiliza un
conjunto de imágenes y objetos gráficos para representar la información y acciones
disponibles en la interfaz. Habitualmente las acciones se realizan mediante manipulación
directa para facilitar la interacción del usuario con la computadora.
Figura 2.1: Ejemplo de Interfaz Gráfica (GNU/Linux)
5
6
Surge como evolución de la línea de comandos de los primeros sistemas operativos
y es pieza fundamental en un entorno gráfico. Como ejemplo de interfaz gráfica de usuario
podemos citar el escritorio del sistema operativo Windows y el entorno X-Window de
Linux y también Aqua de Mac OS X [2].
2.2 Programación Orientada A Objetos (P.O.O.)
La Programación Orientada a Objetos (POO) es un tipo de programación que usa
objetosc y sus interacciones para diseñar aplicaciones y programas de computadora. Está
basado
en
varias técnicas,
incluyendo
herencia,
modularidad, polimorfismo
y
encapsulamiento. Su uso se popularizó a principios de la década de 1990. Actualmente son
muchos los lenguajes de programación que soportan la orientación a objetos.
La programación orientada a objetos expresa un programa como un conjunto de
objetos, que colaboran entre ellos para realizar tareas. Esto permite hacer los programas y
módulos más fáciles de escribir, mantener y reutilizar.
De esta forma, un objeto contiene toda la información que permite definirlo e
identificarlo frente a otros objetos pertenecientes a otras clases e incluso frente a objetos de
una misma clase, al poder tener valores bien diferenciados en sus atributos. A su vez, los
objetos disponen de mecanismos de interacción llamados métodos que favorecen la
comunicación entre ellos. Los métodos y atributos están estrechamente relacionados por la
propiedad de conjunto. Esta propiedad destaca que una clase requiere de métodos para
poder tratar los atributos con los que cuenta.
c
Un objeto es una representación detallada y particular de algo de la realidad. Todo objeto tiene un identidad
o nombre, estado (características definidas generalmente en variables) y comportamiento (sus funciones o
procedimientos) [7].
7
2.2.1 Conceptos fundamentales
La programación orientada a objetos es una nueva forma de programar que trata de
encontrar una solución a muchos problemas. Introduce nuevos conceptos, que superan y
amplían conceptos antiguos ya conocidos. Entre ellos destacan los siguientes:
•
Clase: definiciones de las propiedades y comportamiento de un tipo de objeto
concreto. La instanciación es la lectura de estas definiciones y la creación de un
objeto a partir de ellas.
•
Herencia: Es la facilidad mediante la cual la clase D hereda en ella cada uno de los
atributos y operaciones de C, como si esos atributos y operaciones hubiesen sido
definidos por la misma D. Por lo tanto, puede usar los mismos métodos y variables
públicas declaradas en C. Los componentes registrados como prívate (privados)
también se heredan, pero como no pertenecen a la clase, se mantienen escondidos al
programador y sólo pueden ser accedidos a través de otros métodos públicos.
•
Objeto: entidad provista de un conjunto de propiedades o atributos (datos) y de
comportamiento o funcionalidad (métodos). Se corresponde con los objetos reales
del mundo que nos rodea, o a objetos internos del sistema (del programa). Es una
instancia a una clase.
•
Método: Algoritmo asociado a un objeto (o a una clase de objetos), cuya ejecución
se desencadena tras la recepción de un "mensaje". Desde el punto de vista del
comportamiento, es lo que el objeto puede hacer. Un método puede producir un
cambio en las propiedades del objeto, o la generación de un "evento" con un nuevo
mensaje para otro objeto del sistema.
8
•
Evento: un suceso en el sistema (tal como una interacción del usuario con la
máquina, o un mensaje enviado por un objeto). El sistema maneja el evento
enviando el mensaje adecuado al objeto pertinente. También se puede definir como
evento, a la reacción que puede desencadenar un objeto, es decir la acción que
genera.
•
Mensaje: una comunicación dirigida a un objeto, que le ordena que ejecute uno de
sus métodos con ciertos parámetros asociados al evento que lo generó.
•
Propiedad o atributo: contenedor de un tipo de datos asociados a un objeto (o a una
clase de objetos), que hace los datos visibles desde fuera del objeto y esto se define
como sus características predeterminadas, y cuyo valor puede ser alterado por la
ejecución de algún método.
•
Estado interno: es una variable que se declara privada, que puede ser únicamente
accedida y alterada por un método del objeto, y que se utiliza para indicar distintas
situaciones posibles para el objeto (o clase de objetos). No es visible al programador
que maneja una instancia de la clase.
•
Componentes de un objeto: atributos, identidad, relaciones y métodos.
•
Representación de un objeto: un objeto se representa por medio de una tabla o
entidad que esté compuesta por sus atributos y funciones correspondientes [4].
En comparación con un lenguaje imperativo, una "variable", no es más que un
contenedor interno del atributo del objeto o de un estado interno, así como la "función" es
un procedimiento interno del método del objeto.
9
Existen varios lenguajes de programación orientados a objetos, entre los más
comunes se pueden destacar: C++, java, perl, php, python entre otros.
Muchos de lenguajes de programación no son puramente orientados a objetos, sino
que son híbridos que combinan la POO con otros paradigmas.
Al igual que C++ otros lenguajes, como OOCOBOL, OOLISP, OOPROLOG y
Object REXX, han sido creados añadiendo extensiones orientadas a objetos a un lenguaje
de programación clásico.
10
2.3 CPUCR_2 (8 Bits)
La CPUCR es un CPU diseñado por los ingenieros Randolph Steinvorth y Marco
Antonio Vásquez para la Escuela de Ingeniería Eléctrica de la Universidad de Costa Rica,
el cual fue desarrollado con fines didácticos. Originalmente, la CPUCR tenía un ancho de
palabra de 6 bits, por lo que solo podía tomar 26 = 64 posibles valores (de 0 a 63). De igual
manera, para direccionar la memoria principal, se utilizaba un bus de direcciones de dos
palabras, o sea 12 bits, con lo que se podían direccionar 212 = 4096 posiciones.
La CPUCR_2 es una versión mejorada de la CPUCR original, en la que el principal
cambio es que se cambia el ancho de palabra de 6 bits a 8 bits, con lo que se pueden tener
28 = 256 valores con una palabra, lo cual ayuda a mejorar el desempeño del procesador.
Para direccionar la memoria principal se utilizan dos palabras, con lo que se pueden obtener
216 = 65536 posiciones de memoria.
La CPUCR_2 utiliza múltiples registros, a diferencia del registro único que poseía
la CPUCR original. Con esta nueva característica se hace posible la operación entre dos
registros. Se utiliza una palabra para direccionar los registros. En caso de una instrucción
que opere sobre dos registros se utilizan 4 bits de dicha palabra, dando así 16 posibles
registros. Estos registros se llaman Rd (registro destino) y Rs (registro fuente) [12].
2.3.1 Código de Instrucción
Para la CPUCR_2 se incluye la posibilidad de realizar operaciones de 2 palabras
para algunas instrucciones. Se utiliza entonces un bit especial de la palabra de código de
instrucción para indicar si se realizará una operación de 8 bits o de 16 bits. Luego de esto se
11
toman 4 bits para el Código de operación y los 4 restantes para el modo de
direccionamiento. De esta forma la codificación mostrada en la Figura 2-5.
Figura 2.2: Codificación de una instrucción de la CPUCR_2 [12]
Al tener 4 bits como código de operación, se tiene la posibilidad de codificar más
instrucciones, aumentando así el conjunto de instrucciones a 132 instrucciones, siendo
originalmente de 51 instrucciones [12].
2.3.2 Modos de Direccionamiento
Se utilizan diferentes modos de direccionamiento debido a la nueva capacidad de
tener múltiples registros. Los modos de direccionamiento de la CPUCR_2 se muestran en
el Cuadro 2-1.
Cuadro 2.1 Modos de direccionamiento de la CPUCR_2 [12]
b2-b0
000
001
010
011
100
101
Direccionamiento
Entre Registros
Inmediato
Absoluto
Indirecto
Implícito a registro
Relativo a registros
Dentro de esta lista no se incluyen los direccionamientos cuando b2=b1=1 ya que
estas son excepciones con el bit 4 (bit 8/16) y su codificación se muestra en el Cuadro 2-2.
12
Cuadro 2.2: Casos especiales de direccionamiento en la CPUCR_2 [12]
Direccionamiento
b3-b0
0110 Implícito a status y HLT, NOP, RTI, RTS
Relativo a status
0111
INP, OUT
1110
?
1111
2.3.3 Instrucciones
Para la CPUCR_2, la cantidad de instrucciones aumenta como se mencionó antes.
Además, algunas de ellas cambian de nombre debido a que ya no se opera sobre un solo
registro llamado acumulador sino sobre varios. En el Cuadro 2-3 se resumen todas las
instrucciones de la CPUCR_2 [12].
Cuadro 2.3: Instrucciones de la CPUCR_2 [12]
13
2.4 CPUCR_3 (32 Bits)
La CPUCR_3 incrementa su ancho de palabra notablemente. Se pasa de los 8 bits,
de la CPUCR_2, a 32 bits, obteniendo un ámbito de valores de hasta 232 bits. Como se
observó en las anteriores versiones de la CPUCR, modificando el ancho de palabra se abren
muchas otras opciones para el diseño del microprocesador.
Para la CPUCR_3 ya no es necesario utilizar dos palabras para direccionar la
memoria principal, esto debido al tamaño de palabra. Esto es una de las justificaciones para
utilizar 32 bits como ancho de palabra. Gracias a su tamaño solo se deberá hacer una
operación para acceder a memoria. En cambio, al utilizar dos palabras como dirección era
necesario realizar dos accesos.
La memoria principal puede ser entonces de un tamaño hasta de 232 posiciones de
memoria. Sin embargo esta memoria ya no incluye las instrucciones, se hace necesario el
uso de una memoria de instrucciones [12].
2.4.1 Código de Instrucción
Se busca que la palabra de 32 bits contenga toda la información necesaria para la
instrucción y así evitar múltiples accesos a la memoria de instrucciones para una misma
instrucción, de modo que se utiliza el primer byte (grupo de 8 bits) para almacenar el
código de instrucción y el modo de direccionamiento, de forma similar a la CPUCR_2. Sin
embargo, no se hace necesario la utilización del byte 8/16, teniéndose la distribución
mostrada en la Figura 2-3.
14
Figura 2.3: Organización de las Instrucciones de la CPUCR_3
El resto de la palabra se utilizará entonces para otros datos según el modo de
direccionamiento que se utilice [12].
2.4.2 Modo de Direccionamiento
Los Modos de Direccionamiento que se utilizan son similares a los utilizados en la
CPUCR_2. Estos se resumen en el Cuadro 2-4.
Cuadro 2.4: Modos de direccionamiento CPUCR_3 [12]
b3-b0
0000
0001
0010
0011
0100
0101
0110
0111
1110
1111
Modo de Direccionamiento
Entre Registros
Inmediato
Absoluto
Indirecto
Implícito a Registros
Relativo a Registros
Implícito al Status y HLT, NOP, RTI, RTS
Relativo al Status
Entrada / Salida
Indefinido
15
2.4.3 Instrucciones
Las instrucciones de la CPUCR_3 son similares a las de la CPUCR_2 pero operarán
sobre 32 bits. Además, para la CPUCR_3 se tienen también múltiples registros. Debido al
ancho de palabra, se utilizan de nuevo 16 registros. Sin embargo no se hace necesario el uso
de registros indexados (propiedad de la CPUCR_2 donde se usaban 2 registros para formar
un operando de dos palabras), esto debido al tamaño de los registros.
A continuación, en el Cuadro 2-5 se muestra un resumen de las instrucciones de la
CPUCR_3 para cada modo de direccionamiento y cual es su código de operación. Ambos
valores, el código de operación y el modo de direccionamiento, son dados por 4 bits del
primer byte de una instrucción, el modo de direccionamiento utiliza los bits 0 al 3 mientras
que el código de operación utiliza los bits 4 al 7, cada uno de estos bytes se representa en
hexadecimal para hacer mas sencilla su comprensión [12].
16
Cuadro 2.5: Instrucciones de la CPUCR_3
[12]
17
2.5 GTK+
GTK+ ó The GIMP Toolkit es un conjunto de bibliotecas multiplataforma para
desarrollar interfaces gráficas de usuario (GUI)
[8]
. Inicialmente fueron creadas para
desarrollar el programa de edición de imagen GIMP, sin embargo actualmente son
utilizadas en muchos otros programas en los sistemas GNU/Linux, aunque también pueden
ser compatibles en aplicaciones de Microsoft Windows si se instalan los paquetes
apropiadosd.
Junto a Qt es uno de las bibliotecas más populares para X Window System. GTK+
se ha diseñado para permitir programar con lenguajes como C, C++, C#, Java, Ruby, Perl,
PHP o Python. Licenciado bajo los términos de LGPL, GTK+ es software libre y es parte
del proyecto GNU [3].
El emblema de GTK caracteriza las aplicaciones que están hechas con estas
bibliotecas, por lo que al ver este símbolo (Figura 2-4) sabremos que se está hablando de un
programa hecho con GTK.
Figura 2.4: Emblema de GTK [8]
d
Ver apéndice.
18
2.5.1 Bibliotecas de GTK+
GTK+ se basa en varias bibliotecas del equipo de GTK+ y de GNOME:
•
GLib: Biblioteca de bajo nivel estructura básica de GTK+ y GNOME. Proporciona
manejo de estructura de datos para C, portabilidad, interfaces para funcionalidades
de tiempo de ejecución como ciclos, hilos, carga dinámica o un sistema de objetos.
•
GTK: Biblioteca la cual realmente contiene los objetos y funciones para crear la
interfaz de usuario. Maneja Widgets
e
como ventanas, botones, menús, etiquetas,
deslizadores, pestañas, etc.
•
GDK: Biblioteca que actúa como intermediario entre gráficos de bajo nivel y
gráficos de alto nivel [3].
•
ATK: Biblioteca para crear interfaces con características de una gran accesibilidad
muy importante para personas con discapacidad. Pueden usarse utilerías como lupas
de aumento, lectores de pantalla, o entradas de datos alternativas al clásico teclado o
mouse [6].
•
Pango: Biblioteca para el diseño y reenderezado de texto. Hace hincapié
especialmente en la internacionalización. Pango forma el núcleo del manejo de
fuente y texto para GTK+-2.0 [10].
•
Cairo: Biblioteca de gráficos de dos dimensiones compatible con múltiples
dispositivos de salida. Produce una salida consistente en todas las salidas
multimedia y puede usar la aceleración por hardware si está disponible. Entre las
operaciones que se incluyen en cairo están el trazo y relleno de líneas cúbicas
Bézier, la transformación y composición de imágenes translúcidas en el dibujado
19
del texto. Todas las operaciones de dibujo se pueden transformar mediante cualquier
transformación afín (escalar, rotación, cortar, etc.) [9].
Algunas aplicaciones que usan GTK+ como toolkit son:
•
AbiWord: Procesador de textos.
•
Evolution: Servicio de mensajería.
•
Firefox: Navegador Web.
•
GIMP: Editor gráfico.
•
Chromium: Navegador Web basado en Webkitf y desarrollado en gran medida por
Google
•
Inkscape SVG: Editor de gráficos vectoriales.
•
K-3D: Modelado libre (de 3D) y programa de animación.
•
Marionnet: Un simulador interactivo de redes.
•
Midori: Navegador Web portable
•
Nero Linux: Aplicación de grabación de nueva generación para el sistema operativo
GNU/Linux
e
•
Pidgin: Cliente de mensajería instantánea
•
VMware Player: Maquina virtual [3].
El concepto de Widget se explica más adelante en la página 20
Webkit es un motor de navegación web de código libre y además, es un esqueleto de Mac OS X que se usó
para construir aplicaciones como Safari, Dashboard, Mail entre otras [11].
f
20
2.5.2 Widgets y Objetos más comunes de GTK+2.0
Un widget es una pequeña aplicación o programa, usualmente presentado en
archivos o ficheros pequeños que son ejecutados por un motor de widgets o Widget Engine.
Entre sus objetivos están los de dar fácil acceso a funciones frecuentemente usadas y
proveer de información visual. Sin embargo los widgets pueden hacer todo lo que la
imaginación desee e interactuar con servicios e información distribuida en Internet; pueden
ser vistosos relojes en pantalla, notas, calculadoras, calendarios, agendas, juegos, ventanas
con información del tiempo en su ciudad, etc [5].
Para elaborar un programa utilizando GTK+2.0 es importante conocer algunos de
los widgets y objetos más comunes que se utilizan en la elaboración de un programa, pues
son muchos y hay algunos en especial que resultan muy comunes en la mayoría de
programas elaborados con este tipo de entorno gráfico. La lista completa de widgets y
objetos se puede consultar en la página de Internet de la GNOME
[6]
, a continuación se
mencionan los más comunes.
•
GtkContainer: Corresponde a un contenedor, su función es almacenar un widget y
ubicarlo en una posición específica del contenedor. Existen muchos tipos de
contenedores, los más comunes son: ventanas, tablas, cajas, cajas horizontales, cajas
verticales y cuadernos entre otros.
•
GtkWindow: Corresponde a una ventana, la cual a su vez es un contenedor que
puede almacenar un único objeto en ella. Existen ventanas con ajuste de scroll
horizontal, vertical, ambos o ninguno. A su vez, se puede ubicar la ventana en una
posición específica de la pantalla, con un determinado título, tamaño, borde, etc.
•
GtkButton: Corresponde a un botón. Este botón debe ser ubicado en algún
contenedor y generalmente se conecta a un evento cuando se hace click sobre él,
21
cuando se suelta, cuando esta presionado, cuando modifica su valor etc. Existen
botones comunes, de tipo flechas, tipo casilla de verificación, tipo íconos, etc.
•
GtkTextEntry: Corresponde a una entrada de texto. Debe ser ubicada en un
contenedor, sirve para mostrar un texto o bien para que el usuario pueda introducir
texto en dicha entrada. Generalmente se asocia a un búfer de texto (GtkTextBuffer)
para conectarlo a eventos, señales o bien para hacer interactivo el texto mostrado o
escrito. Dentro de un búfer de texto se pueden ubicar marcas o iteradores de texto
con el fin de ubicar una posición fija o variable, tal como una línea específica, una
palabra en especial o el final del texto entre otros.
•
GtkLabel: Corresponde a una etiqueta. Su principal función es mostrar información
al usuario, ya sea el título o leyenda de un widget, información acerca de la línea o
columna sobre la que está ubicado el cursor. Debe ser almacenado dentro de un
contenedor y se puede modificar su contenido durante la ejecución del programa.
•
GtkMenuBar: Corresponde a una barra de menú. Esta barra es un contenedor y
generalmente se ubica en la parte superior de la ventana dentro de un contenedor de
tamaño fijo, aunque esto queda a preferencia del programador. Dentro de la barra de
menú se pueden adjuntar ítems y subítems de menú para posicionar dentro de ellos
opciones que el usuario pueda seleccionar y generalmente están conectados a un
evento.
•
GtkToolbar: Corresponde a una barra de herramientas. Dentro de ella se pueden
incluir botones o íconos (StockItem), los cuales generalmente están conectados a
eventos. Esta barra es un contenedor y a su vez debe ser ubicada dentro de un
contenedor.
•
GtkDialog: Corresponde a una ventana emergente utilizada para mostrar o
seleccionar información. Esta ventana puede contener un mensaje de error, de
confirmación, un asistente para imprimir o seleccionar archivos, entre otros.
Existen muchos otros widgets utilizados en la elaboración de un programa gráfico,
los cuales pueden estudiarse revisando la página Web de GNOME
[6]
, algunos de ellos
fueron utilizados durante la elaboración de este proyecto, los cuales serán brevemente
explicados cuando se mencione su utilización.
22
CAPITULO 3: Diseño de la Interfaz Gráfica
Para el diseño de la interfaz gráfica, se utilizó el lenguaje de programación C++ con
bibliotecas de GTK, esto para la plataforma GNU/Linux, aunque al principio de la
elaboración del programa se utilizó el programa Dev-C++ para Microsoft Windows con los
paquetes necesarios previamente instalados.
La sintaxis de las funciones e instrucciones de las bibliotecas GTK fueron tomadas
directamente de la página de Internet de GNOME
[6]
, en donde entre la documentación se
explica brevemente cada parámetro de las instrucciones, así como su sintaxis y las
funciones o llamadas que están relacionadas con dicha instrucción.
El programa tiene los archivos main.cpp que contiene las principales funciones y
métodos que se utilizan durante la ejecución del programa, Editor.cpp que contiene todos
los botones, menús, textos y otros widgets que se muestran en la ventana del editor de
textos, Registros.cpp muestra en una ventana los registros del procesador y contiene
además la ventana de memoria. Finalmente, el archivo Interfaz.cpp contiene todas las
clases y métodos utilizados para conectar la Interfaz Gráfica con la etapa de compilación y
simulación del código.
La interacción que existe entre los módulos de la Interfaz Gráfica es una interacción
múltiple, en donde todos los módulos se relacionan entre sí a través de un objeto,
compartiendo así sus métodos y funciones con los demás módulos.
La interacción existente entre todos los módulos se puede observar en el diagrama
de la Figura 3-1.
23
Figura 3.1: Interacción de los módulos de la Interfaz Gráfica
El conjunto de ventanas, que se muestran durante la ejecución del programa se
puede dividir en tres grandes ventanas “principales”:
• Ventana del editor de texto
• Ventana de registros
• Ventana de memoria
También es importante mencionar el archivo main.cpp, pues es el que inicializa y
manipula a todos los demás módulos del programa. A continuación se explica el contenido
del archivo principal del programa, el de cada ventana y el de la interfaz de compilación y
simulación.
3.1 Archivo principal del programa (main)
Es el módulo principal del programa. El mismo contiene la inicialización del
programa, en donde se declaran los valores iniciales o predeterminados del programa.
Seguidamente se llama a la ejecución de la ventana del editor de texto, la cual está
contenida en un método encargado de crear dicha ventana. Este método forma parte de una
clase llamada Editor.
24
Existen además múltiples variables globales, que contienen los valores de cada
registro del procesador, ventana de memoria, puertos, así como de otras variables
necesarias para el correcto funcionamiento del programa (por ejemplo variables que indican
que el proyecto ha sido guardado, compilado, ejecutado, la ruta del archivo abierto o
guardado, etc.). Las funciones contenidas en el main.cpp conectan importantes eventos,
tales como:
1. Cerrar el programa: existe una función encargada de cerrar el programa, por
lo que destruye cualquier objeto o proceso que se esté ejecutando cuando esta
función es llamada.
2. Mostrar ventanas emergentes: muestra una ventana de tipo diálogo con
diferentes mensajes que se le quieran comunicar al usuario. Algunas de ellas se
muestran en las figuras 3.2 y 3.3.
Figura 3.2: Ventana tipo diálogo que muestra los créditos
Figura 3.3: Ventana de confirmación para salir
25
3. Almacenar registros del procesador: existe una función que guarda los
registros del procesador en un archivo llamado Registros.txt una vez que el
programa haya sido ejecutado.
4. Guardar un archivo: existen funciones destinadas a guardar en un archivo, el
contenido del búfer de texto que se esté mostrando en el editor de texto. Se
muestra además un asistente para guardar el archivo, el cual contiene filtros para
tres extensiones (*.cp8, *.c32 y *.txt) para facilitar este proceso al usuario.
Figura 3.4: Asistente para guardar un archivo
5. Abrir un archivo: Al igual que el asistente para guardar un archivo, se creó un
asistente para abrir un archivo, el cual contiene filtros para facilitar la búsqueda
del archivo (extensiones *.cp8, *.c32, *.txt, todas las extensiones soportadas o
todos los archivos).
26
Figura 3.5: Asistente para la apertura de un archivo
6. Guardar copia de respaldo: Se creó una función que guarda en el archivo
“Sin_Nombre.txt” el código escrito por el usuario cada vez que haya un cambio
en el búfer de texto, esto se hace por precaución pues si el programa o la
computadora se cierran inesperadamente el usuario tiene la posibilidad de
recuperar la información ingresada hasta el último cambio en el búfer.
7. Almacenamiento temporal de cambios: se crearon funciones que almacenan
en variables globales los cambios que se hacen en el búfer de texto, esto para
poder ejecutar los comandos undo (deshacer última acción) y redo (rehacer
última acción previamente modificada por el comando undo).
27
8. Cortar, copiar, pegar: Se crearon funciones que permiten al usuario ejecutar
los comandos cortar, copiar, pegar, seleccionar todo, borrar la selección de texto
o limpiar la ventana del editor de texto.
9. Resaltar sintaxis: Se creó una función que resalta en tiempo real la sintaxis, la
cual se ejecuta cada vez que haya un cambio en el búfer de texto. Tiene la
opción de resaltar las palabras reservadas, números, comentarios, caracteres
reservados e instrucciones para las versiones de la CPUCR de 8 bits y de 32 bits
10. Aplicar atributos al texto: Se crearon funciones que aplican algunos atributos
al texto seleccionado. Entre esos atributos se pueden mencionar negrita, color
(verde) y quitar atributos.
11. Compilar el código fuente: Se creó una función que envía para compilación,
los valores actuales de los registros, el código fuente escrito por el usuario y la
ruta del archivo que contiene el código. Antes de compilar, el programa exige
que el código sea guardado si no ha sido guardado antes, o lo guarda si el código
fue abierto o guardado antes.
12. Mostrar Advertencias: Se hizo una función que envía a la sección de Warnings
del editor de textos, las advertencias obtenidas durante la compilación del
código.
13. Ejecutar el programa: Se creó una función que llama a ejecución al programa
previamente compilado. Muestra los registros del procesador o los actualiza
siempre y cuando la compilación haya sido exitosa, de lo contrario lanza una
advertencia indicando que debe compilar exitosamente el código. Esta
advertencia se muestra en la figura 3.6.
28
Figura 3.6: Mensaje de error pre-ejecución
14. Casillas de verificación: Se hicieron funciones que cambian la versión de la
CPUCR para su compilación, ejecución o resaltado de sintaxis. A su vez,
cambian el estado de los botones de check mostrados en la ventana del editor de
textos, para que el usuario pueda identificar y cambiar fácilmente la versión de
la CPUCR.
15. Crear Atributos: Se hizo una función que crea los diferentes atributos que se le
aplican al texto durante la ejecución del programa. Entre los atributos que se
crearon se pueden mencionar:
•
Bold: aplica negrita, se selecciona desde el menú Formato – Negrita.
•
Color: aplica el color verde, se selecciona desde el menú Formato –
Color.
•
Word: aplica negrita y color café, es utilizada para resaltar las palabras
reservadas de la CPUCR.
•
Coment: aplica el color gris, es utilizada para resaltar los comentarios.
•
Num: aplica color morado, es utilizada para resaltar los números y el
signo dólar.
•
Centrar: centra el texto, utilizado para centrar el contenido de los
registros y de la ventana de memoria.
•
Under: subraya el texto, utilizado para resaltar la posición de memoria
que se está utilizando.
29
3.2 Ventana del Editor de Texto
Es la ventana principal del programa, por lo que es la que aparece al usuario cuando
inicia el programa, asimismo, si esta ventana se destruye, se cierra por completo el
programa y cualquier otra ventana o proceso que se este ejecutando.
Figura 3.7: Ventana Principal, Editor de Texto
30
Entre los widgets que se pueden apreciar en la ventana del editor (Figura 3.7) están:
•
Barra de Menú, ítems del menú y sub-ítems del menú, cada uno de ellos
conectado a su respectivo evento. Contiene los ítems: Archivo (Abrir,
Guardar, Guardar como y Salir), Edición (Undo, Redo, Seleccionar todo,
Limpiar ventana, Cortar, Copiar y Pegar), Formato (Color verde, Negrita y
Borrar formato), Ejecutar (Compilar y Ejecutar) y Acerca de… (Créditos).
•
Barra de Herramientas, en este caso se utilizaron botones del tipo “stockitem”, que son íconos predefinidos con su respectiva leyenda. Cada botón
está debidamente conectado a un evento. Estos botones son: Abrir, Guardar,
Cortar, Copiar, Pegar, Compilar, Ejecutar y separadores entre secciones.
•
Ventanas con barras de desplazamiento (scroll), contenedores con
desplazamiento vertical y horizontal.
•
Entradas de texto con búfer, una para escribir el código y otra para mostrar
las advertencias. Cada una de ellas está contenida dentro de una ventana con
scroll.
•
Casillas de verificación (Botones de check), para seleccionar la versión de la
CPUCR con la que se desea trabajar (de 8 bits o de 32 bits, por defecto
aparece marcada la opción de 8 bits).
•
Etiquetas, para indicaciones importantes, en este caso para indicar la leyenda
de cada casilla de verificación y el número de línea sobre la que está el
cursor. Esta última se está actualizando cada 250ms por medio de una
llamada a función para ubicar la posición del cursor e imprimirla en la
etiqueta.
31
•
Contenedores de tipo vertical, horizontal y handlebox. El de tipo vertical
almacena los widgets de manera vertical, análogamente lo hace el de tipo
horizontal. El contenedor de tipo handlebox es una caja que mantiene su
tamaño aún cuando se cambien las dimensiones de la ventana y es
especialmente útil para almacenar barras de menú y de herramientas, además
de permitir arrastrar su contenido para colocarlo en otra posición.
Cabe resaltar también que el editor de textos resalta la sintaxis en tiempo real
conforme se introduce el código de acuerdo a la versión de la CPUCR que esté
seleccionada en los botones de check. El editor de textos reconoce las palabras reservadas
(en mayúsculas y minúsculas) como por ejemplo macro, finmac, wrd, dbwrd, carácter “*”
y carácter “$”, además reconoce los números, los comentarios y las instrucciones de la
CPUCR cada uno con un color diferente tal y como se muestra en el Cuadro 3-1:
Cuadro 3.1: Atributos aplicados a la sintaxis
Entrada
Palabras reservadas y carácter asterisco “*”
Números y signo dólar “$”
Comentarios (desde “;” hasta final de línea)
Instrucciones de la CPUCR
Atributo(s)
Negrita y color café
Color violeta
Color gris
Negrita
Para el reconocimiento de las instrucciones de la CPUCR se utilizaron cadenas del
tipo const char* instrucciones [52], instrucciones_m [52]; pues para la CPUCR de 32 bits
existen 52 nombres diferentes para las instrucciones de la CPUCR (tanto en mayúsculas
como en minúsculas). Para la versión de 8 bits solo existen 38 nombres para las
32
instrucciones, por lo que no fue necesario hacer una re-declaración de todos los términos,
solo los que cambian de nombre (por ejemplo el LD de la versión de 32 bits es LDA en la
versión de 8 bits), los términos sobrantes de la cadena no se utilizan para la versión de 8
bits (sobran: 52 – 38 = 14 posiciones de las variables declaradas en el const char * escritas
anteriormente).
La llamada a la función de marcar sintaxis se hace cada vez que el usuario
modifique el búfer de texto del editor (basta con introducir o borrar un carácter), por lo que
constante y permanentemente se está resaltando la sintaxis.
Prácticamente todas las funciones necesarias para el buen funcionamiento del editor
de textos están dentro del archivo main.cpp, sin embargo fue necesario agregar una función
más para el editor de textos, dicha función es la función de tipo void: insertion (), la cual es
la encargada de ubicar el cursor en el búfer de la entrada de texto, una vez ubicado el
cursor, imprime el número de línea en la etiqueta que está en la parte inferior derecha de la
ventana del editor. Esta etiqueta fue declarada afuera del método que genera la ventana del
editor de textos (variable global), para poder acceder a ella desde el método y la función
encargadas de imprimir adecuadamente los widgets y sus contenidos en la ventana del
editor de textos.
El búfer de texto del editor también es declarado como una variable global, pues es
necesario acceder a él desde diferentes puntos del código, y las llamadas a función de GTK
por una señal solo permiten enviar un argumento a la función, por este motivo se decidió
utilizar variables globales en la elaboración de todo el programa.
33
3.3 Ventana de Registros
Es la ventana que muestra los registros Fuente (Principales) y Destino (Auxiliares)
de la CPUCR. Aparece al usuario cuando se ejecuta el código luego de una compilación
exitosa. Como esta ventana está conectada con el editor de textos, en ella también se
muestran las variables escritas por el usuario, como por ejemplo los macros, wrd, dbwrd y
posiciones de memoria fijas. Además, es desde la ventana de registros que el usuario puede
abrir la ventana de memoria. La ventana de registros se muestra en la Figura 3.8.
Figura 3.8: Ventana de Registros
34
Para colocar los widgets que se pueden apreciar en esta ventana se hizo la
distribución en la ventana que se muestra en la Figura 3.9:
Figura 3.9: Distribución de contenedores para la ventana de registros
De las Figuras 3.8 y 3.9 se puede apreciar que se hizo uso de múltiples contenedores
para ordenar y colocar los widgets en la ventana de registros, como las cajas verticales (hay
4), cajas horizontales (3), cajas tipo handlebox (3), y otras no utilizadas hasta ahora, tal es
el caso del notebook (cuaderno), que permite añadir contenedores de tipo “pestaña” para
poder seleccionar entre varios contenedores. A su vez, un notebok almacena otro
contenedor, el frame (marco), que le da una mejor apariencia colocando una multi-línea en
el borde del contenedor. Para este caso, se pusieron dos pestañas para el notebook (cada
35
una con su respectivo frame), una para mostrar los registros principales y la otra para
mostrar los registros auxiliares de la CPUCR. Los demás widgets utilizados en esta ventana
se declararon de manera muy similar a los del editor de textos (barras de menú y de
herramientas, entradas de texto y búfer de texto, botones, ventanas de scroll y etiquetas).
Esta ventana está conectada con la interfaz de compilación y de simulación tal y
como se muestra en la ¡Error! No se encuentra el origen de la referencia.. Esto permite
que desde la ventana de registros se pueda compilar el código escrito en el editor de texto y
ejecutarlo. Además, si el usuario cambió el valor de algún registro, la ventana de registros
envía al compilador los valores actuales de los registros, con lo que se puede compilar y
ejecutar el código fuente con valores iniciales distintos a los valores por defecto de los
registros (por defecto, los registros y la ventana de memoria tienen todos valores de $0000
o $00 según corresponda).
En esta ventana se puede acceder a la opción de ejecutar paso a paso la simulación,
con lo que se puede ver los cambios que van presentando los registros en cada paso que
avanza la simulación. Para ejecutar esta opción el programa solicita compilar el código
nuevamente, esto para poder compilar con los valores de los registros modificados por el
usuario.
Los puertos de entrada y de salida, así como la ventana de memoria están accesibles
al usuario desde el botón de la barra de herramientas con la leyenda “V.M.” o bien desde el
ítem del menú llamado “Ver” en el sub-ítem “Ventana de memoria” o bien en el sub-ítem
“Puertos”. Ambos abren la misma ventana (que contiene la memoria y los puertos).
Si el usuario compila o ejecuta el código fuente desde la ventana de memoria o
desde el editor, los cambios en los registros se pueden observar desde la ventana de
36
registros ya abierta, sin necesidad de tener que abrir otra ventana de registros para ver los
cambios.
3.4 Ventana de Memoria
Es la ventana que muestra la memoria y los puertos de la CPUCR. Aparece cuando
se le da click desde la ventana de memoria al ítem o botón indicado con ese nombre y las
funciones que la generan y que la operan están contenidas en el mismo módulo que la
ventana de registros (el archivo Registros.cpp). La ventana de memoria se puede apreciar
en la Figura 3.10.
37
Figura 3.10: Ventana de memoria
La función que genera la ventana de memoria se llama “on_button_vm_clicked”.
Como esta ventana también está conectada al editor de texto (por medio de la variable
“user_data”, que recibe de la ventana de registros y es la que contiene la entrada de texto
que contiene el código fuente escrito por el usuario en la ventana del editor de texto) es
posible compilar, ejecutar y ejecutar paso a paso el programa desde ella con solo hacer click
en los botones colocados para ese fin.
Se agregan además las opciones de agregar hasta 10 posiciones de memoria
específicas para poder analizar su comportamiento en cada paso de la ejecución o al final
38
de la misma (ejecutar paso a paso o ejecutar todo, respectivamente). De igual manera, se
puede remover una posición específica previamente agregada si ya no interesa analizar su
comportamiento, o bien remover todas las posiciones si no se desea analizar ninguna. Si la
ejecución se hace paso a paso, el programa irá resaltando con negrita y subrayando la
posición de memoria y su contenido cuando esta cambia de valor, además, posicionará el
ajuste de la ventana con barra de desplazamiento para que el usuario tenga siempre a la
vista la posición que está siendo modificada. De igual manera, si se agregó una posición
específica para visualizar los cambios, esta también será resaltada y subrayada cuando
cambie. Es importante indicar que sólo se resalta y subraya la posición que está siendo
modificada, una vez que se cambie de posición los atributos aplicados a la posición anterior
serán desechos.
El programa tiene también un botón que sirve para indicar que se desea parar la
ejecución del programa, el cual envía un “1” cuando se le da click. Este valor es
reestablecido a cero cuando se compila o ejecuta nuevamente el programa.
Finalmente, se agregó un botón que indica en cual posición de memoria se desea
detener la ejecución El valor donde se desea detener la ejecución está dado por el “spinbutton” (botón con un ámbito de valores numéricos y flechas para seleccionar entre dichos
números).
Para activar la ejecución hasta una posición específica es necesario activar el botón
“Parar en” el cual cambia su leyenda cuando está activado e indica el valor donde se desea
detener la ejecución del programa (en hexadecimal). Así si el botón presenta la leyenda
“$000f” (“0015” en el spin-button) la ejecución se detendrá en esta posición. Por el
contrario si el botón presenta la leyenda “Parar en” entonces la ejecución será realizada
hasta el final (instrucción HLT).
39
Como se mencionó antes, la ventana de memoria contiene los puertos de entrada y
de salida, mostrando el valor que se va a ingresar o exportar cuando se hace acceso a
puertos. Los puertos también modifican sus valores conforme se hace la ejecución paso a
paso.
Hay varias funciones que ayudan al debido funcionamiento de la ventana de
memoria, estas son:
1. void marcar: es la función encargada de resaltar la posición que está siendo
modificada cuando se está ejecutado el programa paso a paso.
2. void add_const: es la función encargada de agregar una posición de memoria en
el cuadro de “Visualizar Cambios”. Se llama a esta función cuando se le da click
al botón de “Agregar”.
3. void remove_const: es la función encargada de eliminar una posición de
memoria del cuadro de “Visualizar Cambios”. Se llama a esta función cuando se
le da click al botón de “Quitar”.
4. void clear_const: es la función encargada de eliminar todas las posiciones de
memoria del cuadro de “Visualizar Cambios”. Se llama a esta función cuando se
le da click al botón de “Limpiar”.
5. void on_button_compile: es la función encargada de llamar a compilar el código
escrito en el editor de texto, con los valores de los registros presentes en la
ventana de registros y que pudieron haber sido modificados por el usuario.
6. void on_button_step_clicked: es la función encargada de ejecutar paso a paso el
código escrito en el editor de texto, con los valores de los registros presentes en
la ventana de registros y que pudieron haber sido modificados por el usuario.
40
7. void on_button_run: es la función encargada de ejecutar el código escrito en el
editor de texto hasta el final o hasta la posición indicada en el botón “Parar en”,
con los valores de los registros de la ventana de registros y que pudieron haber
sido modificados por el usuario.
8. void on_button_stop_position: es la función encargada de detener la ejecución
del programa, envía un “1” al simulador cuando se llama a esta función con el
botón “Detener”.
9. void on_button_stop_point: es la función encargada de obtener la posición de
memoria donde se desea detener la ejecución del programa.
10. void close_regs y void close_win: Destruyen las ventanas de registros y de
memoria respectivamente.
42
CAPITULO 4: Interfaz de Compilación y Simulación
La interfaz de compilación y simulación es la encargada de relacionar la interfaz
gráfica del procesador con la etapa compiladora y la de simulación, por lo tanto todo el
contenido de lo que hay en la interfaz gráfica (editor de texto, registros, ventana de
memoria y puertos) se puede modificar u obtener desde aquí.
Para poder lograr esta interfaz, el programa recibe las variables de simulación,
código fuente, versión de la CPUCR, puertos, registros e indicadores de posición cuando el
usuario decide compilar el proyecto. De esta manera, se tiene en un objeto de interfaz todos
los valores actuales de las variables para que el programa encargado de compilar o simular
el proyecto conozca los parámetros de simulación, restricciones y demás detalles que el
usuario haya seleccionado.
Esta etapa contiene además, atributos y métodos que toman los valores de los
parámetros de simulación para enviarlos a los diferentes widgets encargados de mostrar
estos valores en pantalla.
Entre los atributos de la interfaz se pueden encontrar variables que indican si el
programa fue o no compilado exitosamente, la posición de la ventana de memoria que está
siendo ejecutada, valor de la posición donde se desea detener el programa, registros del
procesador, la ruta del archivo que contiene el código fuente, indicador de detener la
ejecución, versión de la CPUCR, entre otros.
Entre las funciones que se pueden encontrar en esta interfaz, se encuentran
conversores de tipo de dato (de string a char* por ejemplo), funciones que generan
números aleatorios (binarios y hexadecimales, en diferentes tipos y precisión).
43
Entre los métodos que se crearon en la interfaz del programa se encuentran métodos
para compilar, simular y ejecutar paso a paso el programa, además de métodos que
permiten recuperar los registros y variables de simulación de la clase interfaz (esto porque
los atributos fueron declarados como privados).
Es importante hacer la aclaración de que la interfaz gráfica solo imprime
argumentos del tipo char* ó const char*, de ahí la importancia de la función
“string_to_char” (encargada de convertir un string en un char*), pues los objetos utilizados
para recibir los resultados de la compilación y de la simulación, retornan valores del tipo
string.
A continuación se muestra el contenido del texto introducido en la ventana del
editor de texto, ventana de registros y ventana de memoria para dos posibles códigos
introducidos por el usuario. Con esto se muestra el correcto funcionamiento del programa
(interfaz gráfica y compilación). También se pretende mostrar el correcto funcionamiento
de la sección de la ventana de memoria destinado a almacenar posiciones de memoria fijas
para su análisis.
El primer código introducido para hacer las pruebas fue:
Cuadro 4.1: Primer código introducido para la sección de pruebas
Código de Instrucción
Valor
Esperado
$10
Parte Baja
$45
Parte Alta
$12
Código de Instrucción
$64
Primer Código de Prueba
lda $1245
hlt
44
Figura 4.1: Captura obtenida del resultado de la primera prueba
De la comparación entre el Cuadro 4-1 y la Figura 4.1, se puede observar que los
resultados esperados y los obtenidos (respectivamente) son idénticos.
El segundo código introducido para hacer las pruebas fue:
Cuadro 4.2: Segundo código introducido para la sección de pruebas
Código de Instrucción
Valor
Esperado
$10
Parte Baja
$76
Parte Alta
$98
Código de Instrucción
$11
Parte Baja
$32
Parte Alta
$54
dca
Código de Instrucción
$53
hlt
Código de Instrucción
$64
Segundo Código de Prueba
lda $9876
sta $5432
45
Figura 4.2: Captura obtenida del resultado de la primera prueba
De la comparación entre el Cuadro 4.2 y la Figura 4-2 se puede observar que los
resultados esperados y los obtenidos son idénticos. Además, si se compara la Figura 4-1
con la Figura 4-2 se puede observar que el contenido de la entrada de texto destinada a
almacenar posiciones de memoria cambió para las posiciones de memoria $0001 a la
$0009, lo cual es cierto, pues a diferencia del primer código de instrucción (lda absoluto) el
contenido de las posiciones de memoria cambió. De igual modo, se comprueba que las
posiciones de memoria que no tenían ningún valor asociado se les asignó un valor aleatorio.
Como se mencionó en el Capítulo 3, el botón “Detener en” está diseñado para
mostrar el contenido de la posición en la que se desea detener la ejecución del programa, y
a su vez, enviar este valor a la etapa de interfaz. En la Figura 4.3 se muestra el botón
activado con el valor de la posición 48115 en hexadecemal.
Figura 4.3: Prueba al botón "Detener en".
46
Se hicieron dos pruebas para la simulación, una para la simulación completa y otra
para la simulación hasta una posición de memoria específica.
En la prueba de simulación completa se introdujo el código en la ventana del
editor y se compiló (de manera exitosa) tal como se puede apreciar en la Figura 4-4.
Figura 4.4: Ejemplo de simulación
47
Al proceder con la ejecución del programa se obtuvieron los registros del
procesador que se muestran en la Figura 4-5.
Figura 4.5: Registros obtenidos en simulación de prueba
Donde se puede apreciar que la Pila tiene asignado un valor de $00 (se apiló el
registro de estado y luego se desapiló), el contador de programa es $000f (se han avanzado
16 posiciones, desde la posición 0 a la 15, que en hexadecimal es $000f), el acumulador es
$07 ($01+$01-$01+$05+$01=$07), y las banderas de estado N=0 (acumulador es positivo),
V=0 (no hay rebase), I=1 (interrupción), Z=0 (el acumulador es distinto de 0) y C=0 (no
hay acarreo). Lo cual es correcto, pues los valores de los registros son los esperados.
La ventana de memoria se puede apreciar en la Figura 4-6.
48
Figura 4.6: Ventana de memoria en simulación de prueba
La ventana de memoria presenta los códigos de instrucción y valores asociados
correctos, pues son los que debería tener con el código introducido en el editor de textos
(Figura 4-4). Para comprobar los valores expuestos en la ventana de memoria se puede
observar el Cuadro 4.3, donde se explica el valor de cada posición correspondiente al
código fuente de este ejemplo (Nota: p.b.= parte baja, p.a.= parte alta).
49
Posición
$0000
$0001
$0002
$0003
$0004
$0005
$0006
$0007
$0008
$0009
$000a
$000b
$000c
$000d
$000e
$000f
Código
Registro
$00
$01
$25
$76
$11
$00
$01
$35
$20
$05
$25
$11
$10
$01
$66
$46
Instrucción
LDA
p.b.
INA
PHS
STA
p.b.
p.a.
DCA
ADD
p.b.
INA
STA
p.b.
p.a.
PLS
HLT
Cuadro 4.3: Ventana de memoria del ejemplo de simulación
Se utilizó el mismo código de la Figura 4-5 para la simulación hasta una posición
específica de memoria, en este caso hasta la posición $0004 y se obtuvo el resultado
mostrado en la Figura 4-7, de donde se puede apreciar que en efecto el contador de
programa tiene el valor $0004. Del Cuadro 4.3 se puede observar que hasta la posición de
memoria $0004 el acumulador tiene un valor de $01 + $01 = $02. Además, hasta la
posición $0004 se apiló una vez (PHS), por lo que se incrementó en uno el puntero de pila
tal como se muestra en la Figura 4-7.
50
Figura 4.7: Ventana de registros de simulación hasta posición específica de memoria.
Finalmente, se hizo la prueba de simulación paso a paso. Vale la pena resaltar que
por el momento se carece de un simulador paso a paso real, que muestre los verdaderos
valores de los registros, puertos y de la ventana de memoria, por lo que fue necesario
implementar valores aleatorios para cada registro, puerto y para cada posición de la ventana
de memoria con su contenido. Estos valores aleatorios son generados en la sección de
interfaz del programa, pues es allí donde el programa va a recibir los resultados de la
simulación (aunque también podría hacerlo desde el módulo de registros). Al hacerlo de
esta manera se consigue aproximar mucho el comportamiento real del simulador.
51
Los resultados obtenidos de la prueba de simulación paso a paso se muestran en la
Figura 4.4, en la que se puede apreciar que el programa resalta la posición de memoria que
está siendo ejecutada y si ésta estaba en la ventana de “Visualizar Cambios” también allí es
resaltada y modificada con su nuevo contenido, los demás valores permanecen intactos.
Figura 4.8: Prueba de simulación paso a paso
Con estas pruebas (entre otras), se pudo comprobar que la interfaz gráfica es
compatible con otros programas creados con C++ y esto la hace funcional, lo cual es muy
importante pues se tiene un programa que permite escribir código fuente para la CPUCR y
52
obtener resultados de compilación y simulación idénticos a los que se obtendrían con el
procesador real.
Es importante recalcar que el programa se dejó previsto para que el programador lo
una con la etapa de simulación paso a paso, pues al momento de la elaboración del
programa no se contaba con esta parte, sin embargo el programa está previsto para recibir
los resultados de la simulación paso a paso y enviarlos al respectivo objeto encargado de
mostrarlo en pantalla de manera gráfica. Dentro de la clase Interfaz (archivo Interfaz.cpp),
se comentó el código en una sección del método respectivo (compilar, ejecutar o ejecutar
paso a paso) indicando al programador los procedimientos que debe realizar para poder unir
correctamente el simulador con la interfaz gráfica de manera sencilla y desde una misma
sección del programa para no tener que buscar en el resto del código las variables y Widgets
que muestran esta información.
Para realizar esta unión de manera exitosa, se deben de crear los objetos necesarios,
los cuales son hechos por el creador de la etapa de simulación paso a paso. Una vez
establecida esta conexión, la interfaz contiene el código fuente introducido por el usuario,
la ruta del archivo donde se guardó el código, los valores actuales de todas las variables de
simulación y registros del procesador (descritos e identificados debidamente en el código
fuente del archivo Intefaz.cpp), por lo que el usuario puede disponer de esta información
para unir la interfaz gráfica con esta etapa de simulación.
Con los aspectos descritos anteriormente se logran cumplir los objetivos del
proyecto, pues se tiene una interfaz gráfica capaz de reconocer texto y editarlo, compilarlo
y mostrar resultados de simulación para las distintas versiones de la CPUCR, además de
poder ejecutar la simulación paso a paso, hasta una posición específica o detenerla en algún
instante preciso. También es posible compilar y ejecutar el programa con los valores de los
53
registros modificados manualmente por el usuario desde la ventana de registro y la ventana
de memoria, teniendo así un programa de características similares a las del emulador
EMU8086, que es lo que se pretendía con este proyecto.
52
CAPITULO 5: Conclusiones y Recomendaciones
Conclusiones:
• La interfaz gráfica de usuario para la CPUCR creada con bibliotecas GTK+2.0 es
funcional, útil, estética y fácil de usar.
• La interfaz gráfica de usuario para la CPUCR permite de manera sencilla
cambiar los valores de los registros y variables del procesador.
• La interfaz gráfica permite simular un programa introducido por el usuario, ya
sea de manera completa, hasta una posición específica de memoria o bien simular
el programa paso a paso.
• Las características del procesador CPUCR se pueden emular con una interfaz
gráfica de usuario creada con GTK+2.0 unido a un compilador y un simulador.
• La interfaz gráfica de usuario para la CPUCR tiene características similares a las
que presenta el EMU8086 para el procesador Intel 8086.
• Las bibliotecas de GTK+2.0 proveen características que permiten al programador
crear software con entorno gráfico que permite al usuario utilizar de manera
sencilla un programa.
53
Recomendaciones:
• Si se desea agregar o modificar algún botón, menú u otro elemento al programa,
de debe ubicar en el archivo de código respectivo (main.cpp, Editor.cpp, Interfaz,
ó Registros.cpp) e introducir el nuevo contenido, los comentarios escritos en el
código fuente del programa permiten al usuario ubicar para qué sirve cada
sección.
• Si se quiere cambiar algún detalle del programa y se desconoce la sintaxis a
utilizar, se recomienda utilizar el manual de referencia para GTK+2.0 disponible
en la página de Internet de Gnome [6], además de tener conocimientos previos de
programación orientada a objetos en C++.
• Si durante la ejecución del programa se presenta un cierre inesperado, se puede
recuperar el código fuente introducido antes del cierre siempre y cuando no se
introduzca texto nuevo en la ventana del editor de textos. Para recuperar el
trabajo realizado basta con abrir el archivo “Sin_Nombre.txt” creado en la carpeta
donde se ejecuta el programa.
• Se recomienda compilar completamente y “desde cero” el compilador, el
simulador y luego la interfaz gráfica, para evitar inconvenientes en la ejecución
del programa. Para esto se disponen los archivos “makefile” necesarios.
• Para compilar el programa y ejecutarlo correctamente en GNU/Linux deben
instalarse los paquetes, bibliotecas y aplicaciones especificados en la sección de
ANEXOS de este informe o bien en la página de Internet de Gnome [6].
53
CAPITULO 6: BIBLIOGRAFÍA
Libros:
1. Gottfried Byron. “Programación en C”, Serie Schawm, 2° Edición, Editorial
McGraw-Hill/Interamericana de España S.A.U, Año 1997.
Páginas Web:
2. Wikipedia. “Interfaz Gráfica de Usuario”, 25 de marzo del 2009
http://es.wikipedia.org/wiki/Interfaz_gr%C3%A1fica_de_usuario
3. Wikipedia. “GTK+”, 25 de mayo del 2009
http://es.wikipedia.org/wiki/Gtk
4. Wikipedia. “Programación Orientada a Objetos”, 15 de mayo del 2009
http://es.wikipedia.org/wiki/Programaci%C3%B3n_orientada_a_objetos
5. Wikipedia. “Widget”, 20 de junio del 2009
http://es.wikipedia.org/wiki/Widget
6. GNOME Documentation Library. “GTK+ Reference Manual”, 26 de junio del 2009
http://library.gnome.org/devel/gtk/unstable/
7. Diccionario Informático. “Definición de Objeto”, 28 de julio del 2009,
http://www.alegsa.com.ar/Dic/objeto.php
8. The GTK+ Project. “What is GTK+”, 28 de julio del 2009,
http://www.gtk.org/
9. Package: libcairo-perl (1.061-1). “Interfaz de Perl para la biblioteca de gráficos
Cairo”, 30 de julio del 2009, http://packages.debian.org/es/sid/libcairo-perl
10. Package: libpango1.0-dev (1.22.2-0ubuntu1.1). “Archivos de desarrollo para
Pango”, 30 de julio del 2009,
http://packages.ubunut.com/es/intrepid/libpango1.0-dev
11. Desarrolloweb.com. “Qué es Webkit”, 30 de julio del 2009,
http://www.desarrolloweb.com/articulos/que-es-webkit.html
54
Trabajos Finales de Graduación:
12. Ricardo Barquero Carranza y Mauricio Guillén Torelli. “Desarrollo de un modelo
sintetizable para la CPUCR de 32 bits con pipeline”. Proyecto Eléctrico, Escuela de
Ingeniería Eléctrica, Universidad de Costa Rica, junio del 2008.
55
APÉNDICES
Archivo Makefile para la interfaz gráfica con el compilador y el simulador
#g++ -Wall -g main.cpp compiler.o memory.o parser.o scanner.o Editor.h Editor.cpp Interfaz.h Interfaz.cpp
Registros.h #Registros.cpp -o CPUCR `pkg-config --cflags gtk+-2.0 pkg-config --libs gtk+-2.0`
# archivo make para compilar el ensamblador de la CPUCR con el compilador
SOURCES = main.cpp Editor.cpp Interfaz.cpp Registros.cpp
OBJS = ${SOURCES:.cpp=.o}
OBJ
= compiler.o memory.o parser.o scanner.o simulator.o registers.o
CFLAGS = `pkg-config --cflags gtk+-2.0`
LDADD = `pkg-config --libs gtk+-2.0`
CC = g++
PACKAGE = CPUCR
all : ${OBJS}
${CC} -o ${PACKAGE} ${OBJ} ${OBJS} ${LDADD}
main.o: main.cpp Editor.h Interfaz.h Registros.h
$(CC) $(CFLAGS) $(LDADD) -c -o $@ $<
Editor.o : Editor.cpp Editor.h Interfaz.h Registros.h
$(CC) $(CFLAGS) $(LDADD) -c -o $@ $<
Interfaz.o : Interfaz.cpp Editor.h Interfaz.h Registros.h memory.hh compiler.hh
$(CC) $(CFLAGS) $(LDADD) -c -o $@ $<
Registros.o : Registros.cpp Editor.h Interfaz.h Registros.h compiler.hh
$(CC) $(CFLAGS) $(LDADD) -c -o $@ $<
.cpp.o:
${CC} ${CFLAGS} -c $<
# fin del archivo
56
Archivo Makefile para el compilador y simulador
PROGRAM = cpucr
CXXSOURCES = sis.cc parser.cc scanner.cc compiler.cc memory.cc simulator.cc registers.cc # list of
source files
CXXOBJECTS = $(CXXSOURCES:.cc=.o) # expands to list of object files
CXXFLAGS = -Wall
CXX = g++
all: $(PROGRAM)
# Link target: automatically builds its object dependencies before
# executing its link command.
$(PROGRAM): $(CXXOBJECTS)
$(CXX) -o $@ $(CXXOBJECTS)
# Object targets: rules that define objects, their dependencies, and
# a list of commands for compilation.
parser.cc : parser.yy
bison -S lalr1.cc -o $@ $<
scanner.cc : scanner.ll
flex -d -o$@ $<
sis.o: sis.cc compiler.hh memory.hh
$(CXX) $(CXXFLAGS) -c -o $@ $<
parser.o : parser.cc compiler.hh mnemonic.hh
$(CXX) $(CXXFLAGS) -c -o $@ $<
compiler.o : compiler.cc compiler.hh
$(CXX) $(CXXFLAGS) -c -o $@ $<
scanner.o : scanner.cc compiler.hh
$(CXX) $(CXXFLAGS) -c -o $@ $<
memory.o : memory.cc memory.hh
$(CXX) $(CXXFLAGS) -c -o $@ $<
simulator.o : simulator.cc simulator.hh registers.hh
$(CXX) $(CXXFLAGS) -c -o $@ $<
resgisters.o : registers.cc registers.hh
$(CXX) $(CXXFLAGS) -c -o $@ $<
# Clean target: "make -f Makefile.Linux clean" to remove unwanted objects and executables.
clean:
$(RM) -f $(CXXOBJECTS) $(PROGRAM)
57
Archivo Editor.h
// Copyright (c) 2009 Universidad de Costa Rica, Escuela de Ingenieria Eléctrica
// Author: Jairo Alberto Roldán Morales
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
/***************************************************************************************
Librerias y funciones a utilizar en el programa
***************************************************************************************/
#ifndef EDITOR_H
#include <string.h>
#include <gtk/gtk.h>
// Libreria "Estandar" GTK
#include <stdio.h>
// Libreria para funciones basicas de C
#include <stdlib.h>
// Libreria que contiene la funcion Random
using namespace std;
class Editor{
public:
int bits;
gpointer user_data;
char *Advert;
//Nombre de la clase
//se puede acceder desde el cpp
//Atributo (cualidades de la clase)
//Atributo que envia el codigo
void create(int, gpointer, char*);
void win(int, gpointer, char*);
};
#endif
//Metodo que esta en el archivo.cpp
58
Archivo Interfaz.h
// Copyright (c) 2009 Universidad de Costa Rica, Escuela de Ingenieria Eléctrica
// Author: Jairo Alberto Roldán Morales
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
/***************************************************************************************
Librerias y funciones a utilizar en el programa
***************************************************************************************/
#ifndef INTERFAZ_H
#include <gtk/gtk.h>
#include <string.h>
#include <string>
#include <gtk/gtk.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
// Librerias
// Libreria que contiene la funcion Random
using namespace std;
class Interfaz{
// Nombre de la clase
private:
int compilado;
int posicion_vm;
// Atributos que se desean retornar
// Programa compilado exitosamente
// Valor de donde se esta realizando o interrumpiendo la
ejecucion
int detener;
string vm1, vm2, vm3, vm4;
string vm5, vm6, vm7, vm8;
char* Adv;
char* R_I;
char* Port_in;
char* Port_out;
char* Pp;
// Detener Compilacion
// Primera mitad de la Ventana de memoria
// Segunda mitad de la Ventana de memoria
// Warnings
// Registro de instrucciones
// Puerto de entrada
// Puerto de salida
// Pila
59
char* Pa;
char* PCp;
char* PCa;
char* Ap;
char* Aa;
// Contador de programa
// Acumulador
char* Np;
char* Na;
char* Vp;
char* Va;
char* Ip;
char* Ia;
char* Zp;
char* Za;
char* Cp;
char* Ca;
public:
// Banderas de Estado
// Metodos y otros de la clase
char *ruta;
const char *version;
char *codigo;
int Interrupcion;
// Ruta del archivo donde se tiene el codigo
// Version de la CPUCR, puede ser 8 o 32
// Envia el codigo escrito en el editor
/*----------------- Metodos ------------------*/
void setCMPL(char*, const char*, char*, int, char*, const char*, const char*, char*, char*, char*,
char*, char*,
char*, char*, char*, char*, char*, char*, char*, char*, char*, char*, char*);
void setStep(char*, const char*, int, int);
// Ejecuta el programa paso a paso
void setRun(char*, const char*, int, int, string);
int getCompilado(); // Dice si el proyecto fue compilado correctamente o no
int getPosicion_VM(); // Dice la posicion que se esta ejecutando en la ventan de memoria
string getVm1();
// Devuelve la ventana de memoria (bloque 1)
string getVm2();
// Devuelve la ventana de memoria (bloque 2)
string getVm3();
// Devuelve la ventana de memoria (bloque 3)
string getVm4();
// Devuelve la ventana de memoria (bloque 4)
string getVm5();
// Devuelve la ventana de memoria (bloque 1)
string getVm6();
// Devuelve la ventana de memoria (bloque 2)
string getVm7();
// Devuelve la ventana de memoria (bloque 3)
string getVm8();
// Devuelve la ventana de memoria (bloque 4)
char* getADV();
// Devuelve las advertencias
char* getR_I(); // Devuelve el registro de instrucciones
char* getPort_IN();
// Devuelve el puerto de entrada
char* getPort_OUT();
// Devuelve el puerto de salida
char* getPP();
char* getPA();
char* getPCP();
char* getPCA();
char* getAP();
char* getAA();
// Devuelve la Pila
// Devuelve el Contador de Programa
// Devuelve el Acumulador
60
// Devuelve las banderas de estado
char* getNP();
char* getNA();
char* getVP();
char* getVA();
char* getIP();
char* getIA();
char* getZP();
char* getZA();
char* getCP();
char* getCA();
};
#endif
// N
// V
// I
// Z
// C
61
Archivo Registros.h
// Copyright (c) 2009 Universidad de Costa Rica, Escuela de Ingenieria Eléctrica
// Author: Jairo Alberto Roldán Morales
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
/***************************************************************************************
Librerias y funciones a utilizar en el programa
***************************************************************************************/
#ifndef REGISTROS_H
#include <string.h>
#include <gtk/gtk.h>
#include <stdio.h>
#include <stdlib.h>
#define CH 500
using namespace std;
class Registros{
public:
int bits;
gpointer user_data;
char *dire; // Direccion
char *ppP;
// Registros
char *cpP;
char *aaP;
char *ppA;
char *cpA;
char *aaA;
char *nnp;
// Banderas
char *vvp;
char *iip;
char *zzp;
char *ccp;
char *nna;
char *vva;
char *iia;
char *zza;
char *cca;
// Libreria "Estandar" GTK
// Libreria para funciones basicas de C
// Libreria que contiene la funcion Random
62
char *vvmm1, *vvmm2, *vvmm3, *vvmm4;
char *p_in;
char *p_out;
void create_window(int, gpointer, char*, char*, char*, char*, char*, char*, char*, char*, char*, char*,
char*,
char*, char*, char*, char*, char*, char*, char*, char*, char*, char*, char*,
char*);
void Ventana
char*,char*,
(int, gpointer, char*, char*, char*, char*, char*, char*, char*, char*, char*,
char*, char*, char*, char*, char*, char*, char*, char*, char*, char*, char*,
char*);
//Metodo que esta en el archivo.cpp
};
#endif
63
Archivo main.cpp
// Copyright (c) 2009 Universidad de Costa Rica, Escuela de Ingenieria Eléctrica
// Author: Jairo Alberto Roldán Morales
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
/***************************************************************************************/
/*********************************** Inicio Programa*************************************/
/***************************************************************************************/
#include <gtk/gtk.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <time.h>
#include <ctype.h>
#include "Registros.h"
#include "Editor.h"
#include "Interfaz.h"
#define SIZE_MAX 5000
#define SIZEV 680
#define SIZEH 570
#define SIZE_VM 65536
// Tamaño de la ventana de memoria, debe ser de 65536
/*--------------------------------Metodos---------------------------------*/
void cerrar(GtkWidget *widget, gpointer *data);
void creditos (GtkWidget *wid, GtkWidget *win);
void confirmation(GtkWidget *button, gpointer user_data);
void on_button_vm_clicked (GtkButton * button, gpointer user_data);
void guardado (GtkWidget *win, gpointer user_data);
void guardar (char *nombre, gpointer user_data);
void abrir (char *nombre, gpointer user_data, int longitud);
void on_button_open_clicked (GtkButton * button, gpointer user_data);
void on_button_save_clicked (GtkButton * button, gpointer user_data);
void on_button_save_as_clicked (GtkButton * button, gpointer user_data);
void savetemp (GtkWidget *button, gpointer user_data);
void undo_redo (GtkButton * button, gpointer user_data);
64
void on_button_undo_clicked (GtkButton * button, gpointer user_data);
void on_button_redo_clicked (GtkButton * button, gpointer user_data);
void on_button_cut_clicked (GtkButton * button, gpointer user_data);
void on_button_copy_clicked (GtkButton * button, gpointer user_data);
void on_button_paste_clicked (GtkButton * button, gpointer user_data);
void on_button_select_clicked (GtkButton * button, gpointer user_data);
void on_button_mark_clicked (GtkButton * button, gpointer user_data);
void on_button_bold_clicked (GtkButton * button, gpointer user_data);
void on_button_color_clicked (GtkButton * button, gpointer user_data);
void on_button_unbold_clicked (GtkButton * button, gpointer user_data);
void delete_clicked (GtkButton * button, gpointer user_data);
void clear_clicked (GtkButton * button, gpointer user_data);
void on_button_compile_clicked (int bits, gpointer user_data);
void warnings_changed (int bits, gpointer user_data);
void on_button_run_clicked (int bits, gpointer user_data);
void check_button_clicked(GtkButton * button, gpointer user_data);
void check_button_unclicked(GtkButton * button, gpointer user_data);
void pressed(GtkButton *button, gpointer user_data);
void create_tags (GtkTextBuffer *buffer);
char *string_to_char(string in);
using namespace std;
// P.o.o
/*--------------------------Variables Globales---------------------------*/
char *princPila, *princPC, *princAcum;
char *princN, *princV, *princI, *princZ, *princC;
char *AuxPila, *AuxPC, *AuxAcum;
char *AuxN, *AuxV, *AuxI, *AuxZ, *AuxC;
char *advertencias, *memoria1, *memoria2, *memoria3, *memoria4, *direccion;
char *Puerto_entrada, *Puerto_salida, *Registro_de_Instrucciones;
char *oldtext, *currenttext;
const char *versioncpucr = "8";
int saved=0, proyecto_compilado=1, un_re, act, redoactivable;
int P_VM=65537;
string V_M = "$0000";
/*-----------------------------------------------------------------------*/
/***************************************************************************************
*/
/*****************************************Main******************************************
*/
/***************************************************************************************
*/
int main (int argc, char *argv[])
{
gtk_init (&argc, &argv);
saved = 5;
Editor Editor1;
// Main
// Inicializacion del programa
//Crea el objeto Editor
65
Editor1.win(8, NULL, advertencias);
gtk_main ();
return 0;
// Metodo que crea la ventana del editor
}
/***************************************************************************************
*/
/**************************************Funciones*****************************************/
/***************************************************************************************
*/
/*-----------------------------------------------------------------------------------*/
/*************************************Ventanas****************************************/
/*-----------------------------------------------------------------------------------*/
void cerrar(GtkWidget *widget, gpointer *data)
{
gtk_main_quit();
}
void creditos (GtkWidget *wid, GtkWidget *win)
{
GtkWidget *dialog = NULL;
// Cierra el programa
/*************/
// Funcion que muestra un dialogo
// Declaracion de "Variables"
dialog = gtk_message_dialog_new (GTK_WINDOW (win), GTK_DIALOG_MODAL,
GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE, "Universidad de Costa Rica - Escuela de Ingenieria
Electrica\nCreado por: Jairo Roldan Morales - Interfaz Grafica\nEdgar Villalobos Ortega - Compilador y
Simulador\nComo Proyectos Electricos - Junio 2009\nProfesor Coordinador: Roberto Rodriguez Rodriguez");
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER);
// Posicion de la
ventana de dialogo
gtk_dialog_run (GTK_DIALOG (dialog));
// Corre el dialogo
gtk_widget_destroy (dialog);
// Destructor del dialogo
}
/*************/
void guardado (GtkWidget *button, gpointer user_data)
// Funcion que guada los registros de la
CPUCR
{
GtkWidget *dialog = NULL;
// Declaracion de "Variables"
GtkTextBuffer *buffer;
GtkTextIter start, end;
int v;
gchar *variables;
FILE *fpt;
g_assert (GTK_IS_TEXT_VIEW (user_data));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (user_data));
gtk_text_buffer_get_start_iter(GTK_TEXT_BUFFER (buffer), &start);
gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER (buffer), &end);
variables = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(buffer), &start, &end, FALSE);
fpt = fopen("Registros.txt", "w+");
66
fprintf (fpt, "***************************CPUCR de %s Bits***************************\n\n\n",
versioncpucr);
fprintf (fpt, "***REGISTROS PRINCIPALES***\n\n");
fprintf (fpt, "\nAcumulador:\n%s \n", princAcum);
fprintf (fpt, "\nBanderas de Estado:\nN=%s\nV=%s\nI=%s\nZ=%s\nC=%s\n", princN, princV, princI,
princZ, princC);
fprintf (fpt, "\nContador de Programa:\n%s \n", princPC);
fprintf (fpt, "\nPila:\n%s \n", princPila);
v = atoi(versioncpucr);
if(v!=8)
{
fprintf (fpt, "\n\n\n***REGISTROS AUXILIARES***\n\n");
fprintf (fpt, "\nAcumulador:\n%s \n", AuxAcum);
fprintf (fpt, "\nBanderas de Estado:\nN=%s\nV=%s\nI=%s\nZ=%s\nC=%s\n", AuxN, AuxV, AuxI, AuxZ,
AuxC);
fprintf (fpt, "\nContador de Programa:\n%s \n", AuxPC);
fprintf (fpt, "\nPila:\n%s \n", AuxPila);
}
fprintf (fpt, "\n\n\n***PUERTOS***\n\n");
fprintf (fpt, "\nPuerto de Entrada:\n%s \n", Puerto_entrada);
fprintf (fpt, "\nPuerto de Salida:\n%s \n", Puerto_salida);
fprintf (fpt, "\n\n\n***VARIABLES***\n\n");
fprintf (fpt, "%s\n", variables);
fprintf (fpt, "\n\n\n***VENTANA DE MEMORIA***\n\n");
fprintf (fpt, "%s", memoria1);
fprintf (fpt, "%s", memoria2);
fprintf (fpt, "%s", memoria3);
fprintf (fpt, "%s", memoria4);
fprintf (fpt, "\n\n****************************FIN DE
ARCHIVO****************************");
fclose(fpt);
dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_INFO,
GTK_BUTTONS_CLOSE, "Registros guardados en el archivo 'Registros.txt'"); //Lo que imprime la
ventana de informacion
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER);
// Posicion de la
ventana de dialogo
gtk_dialog_run (GTK_DIALOG (dialog));
// Corre el dialogo
gtk_widget_destroy (dialog);
// Destructor del dialogo
}
/*************/
void confirmation(GtkWidget *button, gpointer user_data)
// Confirmacion para guardar antes de
salir
{
GtkWidget *window, *label, *cajav, *cajah, *spacev, *spaceh;
GtkWidget *button_yes, *button_no;
67
window =
// Ventana emergente
gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Confirmacion");
gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER);
gtk_widget_set_usize(GTK_WIDGET (window), 250, 180);
cajav =
gtk_vbox_new(FALSE, 20);
gtk_container_add(GTK_CONTAINER(window), cajav);
spacev =
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(cajav), spacev);
label =
gtk_label_new("Desea guardar el documento \nantes de salir??");
gtk_container_add(GTK_CONTAINER(cajav), label);
gtk_widget_set_usize(GTK_WIDGET (label), 250, 40);
cajah =
gtk_hbox_new(TRUE, 0);
gtk_container_add(GTK_CONTAINER(cajav), cajah);
spaceh =
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(cajah), spaceh);
button_yes =
gtk_button_new_with_label("Si");
programa
gtk_container_add(GTK_CONTAINER(cajah), button_yes);
gtk_widget_set_usize(GTK_WIDGET (button_yes), 50, 15);
button_no =
gtk_button_new_with_label("No");
gtk_container_add(GTK_CONTAINER(cajah), button_no);
gtk_widget_set_usize(GTK_WIDGET (button_yes), 50, 15);
// Boton para guardar el
// Boton para salir sin guardar
spaceh =
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(cajah), spaceh);
spacev =
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(cajav), spacev);
g_signal_connect ((gpointer) button_yes, "clicked", G_CALLBACK (on_button_save_clicked), (gpointer)
user_data);
g_signal_connect ((gpointer) button_yes, "released", G_CALLBACK (cerrar), NULL);
g_signal_connect ((gpointer) button_no, "clicked", G_CALLBACK (cerrar), NULL);
gtk_widget_show_all(window);
}
void warnings_changed (int bits, gpointer user_data)
{
68
GtkTextBuffer *buffer;
g_assert (GTK_IS_TEXT_VIEW (user_data));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (user_data));
if(saved!=5)
{
gtk_text_buffer_set_text (buffer, advertencias, -1);
}
}
/*-----------------------------------------------------------------------------------*/
/*************************************Archivos****************************************/
/*-----------------------------------------------------------------------------------*/
/*************/
void abrir (char *nombre, gpointer user_data, int longitud)
// Abre un archivo y copia el
contenido en
{
// el editor de texto
GtkTextBuffer *buffer;
GtkTextIter start, end;
string a, c;
char* s;
int i, cont;
FILE *fpt;
el que recibio
fpt = fopen(nombre, "r");
on_button_open_clicked
cont = 0;
fseek(fpt, 0, SEEK_END);
cont = ftell(fpt);
fclose(fpt);
g_assert (GTK_IS_TEXT_VIEW (user_data));
texto
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (user_data));
el texto del editor
gtk_text_buffer_get_start_iter(GTK_TEXT_BUFFER (buffer), &start);
gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER (buffer), &end);
gtk_text_buffer_get_bounds (buffer, &start, &end);
gtk_text_buffer_delete (buffer, &start, &end);
fpt = fopen(nombre, "r");
for(i=0; i<cont; i++)
{
a = getc(fpt);
uno por uno
c = c + a;
}
fclose(fpt);
s = string_to_char(c);
// Abre un archivo con nombre,
// de la funcion
// Toma la ventana del editor de
// Crea un buffer conectado con
// Toma los caracteres del archivo
// Cierra el archivo
69
gtk_text_buffer_set_text (buffer, s, -1);
archivo en
// escribe el texto obtenido del
return;
}
/*************/
void guardar (char *nombre, gpointer user_data)
{
GtkTextBuffer *buffer;
GtkTextIter start;
GtkTextIter end;
gchar *textin;
FILE *fpt;
fpt = fopen(nombre, "w+");
g_assert (GTK_IS_TEXT_VIEW (user_data));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (user_data));
gtk_text_buffer_get_start_iter(GTK_TEXT_BUFFER (buffer), &start);
gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER (buffer), &end);
textin = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(buffer), &start, &end, TRUE); // Incluye
caracteres ocultos
fprintf (fpt, "%s", textin);
fprintf (fpt, "\n");
fclose(fpt);
return;
}
/*************/
void on_button_open_clicked (GtkButton * button, gpointer user_data)
{
GtkWidget *window, *dialog;
GtkFileFilter *filter8, *filter32, *filtertxt, *filter_suported, *filter_all;
int i, llevo, cont;
char a;
string str;
FILE *fpt;
filter_suported = gtk_file_filter_new();
gtk_file_filter_add_pattern (GTK_FILE_FILTER(filter_suported), "*.cp8");
gtk_file_filter_add_pattern (GTK_FILE_FILTER(filter_suported), "*.c32");
gtk_file_filter_add_pattern (GTK_FILE_FILTER(filter_suported), "*.txt");
gtk_file_filter_set_name (GTK_FILE_FILTER(filter_suported), ("All Suported"));
filter8 = gtk_file_filter_new();
gtk_file_filter_add_pattern (GTK_FILE_FILTER(filter8), "*.cp8");
gtk_file_filter_set_name (GTK_FILE_FILTER(filter8), ("*.cp8"));
filter32 = gtk_file_filter_new();
gtk_file_filter_add_pattern (GTK_FILE_FILTER(filter32), "*.c32");
gtk_file_filter_set_name (GTK_FILE_FILTER(filter32), ("*.c32"));
70
filtertxt = gtk_file_filter_new();
gtk_file_filter_add_pattern (GTK_FILE_FILTER(filtertxt), "*.txt");
gtk_file_filter_set_name (GTK_FILE_FILTER(filtertxt), ("*.txt"));
filter_all = gtk_file_filter_new();
gtk_file_filter_add_pattern (GTK_FILE_FILTER(filter_all), "*");
gtk_file_filter_set_name (GTK_FILE_FILTER(filter_all), ("All Files"));
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
dialog = gtk_file_chooser_dialog_new ("Abrir", GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN,
GTK_RESPONSE_ACCEPT, NULL);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(dialog), filter_suported);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(dialog), filter8);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(dialog), filter32);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(dialog), filtertxt);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(dialog), filter_all);
if (gtk_dialog_run ( GTK_DIALOG(dialog) ) == GTK_RESPONSE_ACCEPT)
{
char *filename;
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
str = (string)filename;
direccion = string_to_char(str);
saved = 3;
llevo = 0;
fpt = fopen(filename, "r");
cont = 0;
fseek(fpt, 0, SEEK_END);
cont = ftell(fpt);
for(i=0; i<cont; i++)
{
a = getc(fpt);
// Toma los caracteres del archivo uno por uno
if(!isalnum(a))
{
llevo = llevo + 1;
}
}
fclose(fpt);
abrir (filename, user_data, llevo-1);
g_free (filename);
}
gtk_widget_destroy (dialog);
}
/*************/
void on_button_save_as_clicked (GtkButton * button, gpointer user_data)
{
GtkWidget *window, *dialog;
71
GtkFileFilter *filter8, *filter32, *filtertxt;
filter8 = gtk_file_filter_new();
gtk_file_filter_add_pattern (GTK_FILE_FILTER(filter8), "*.cp8");
gtk_file_filter_set_name (GTK_FILE_FILTER(filter8), ("*.cp8"));
filter32 = gtk_file_filter_new();
gtk_file_filter_add_pattern (GTK_FILE_FILTER(filter32), "*.c32");
gtk_file_filter_set_name (GTK_FILE_FILTER(filter32), ("*.c32"));
filtertxt = gtk_file_filter_new();
gtk_file_filter_add_pattern (GTK_FILE_FILTER(filtertxt), "*.txt");
gtk_file_filter_set_name (GTK_FILE_FILTER(filtertxt), ("*.txt"));
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
dialog = gtk_file_chooser_dialog_new ("Save File", GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE,
GTK_RESPONSE_ACCEPT, NULL);
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER(dialog), "Sin_Nombre.txt");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(dialog), filter8);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(dialog), filter32);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(dialog), filtertxt);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
char *filename;
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
direccion = filename;
saved = 2;
guardar (filename, user_data);
g_free (filename);
}
;
gtk_widget_destroy (dialog);
}
/*************/
void on_button_save_clicked (GtkButton * button, gpointer user_data)
{
GtkWidget *window, *dialog;
GtkFileFilter *filter8, *filter32, *filter_all;
GtkTextBuffer *buffer;
GtkTextIter start;
GtkTextIter end;
gchar *textin;
char *filename;
FILE *fpt;
// Toma los caracteres del archivo uno por uno
72
if(saved == 5)
// Pregunta si el archivo esta en
blanco
{
filter8 = gtk_file_filter_new();
gtk_file_filter_add_pattern (GTK_FILE_FILTER(filter8), "*.cp8");
gtk_file_filter_set_name (GTK_FILE_FILTER(filter8), ("*.cp8"));
filter32 = gtk_file_filter_new();
gtk_file_filter_add_pattern (GTK_FILE_FILTER(filter32), "*.c32");
gtk_file_filter_set_name (GTK_FILE_FILTER(filter32), ("*.c32"));
filter_all = gtk_file_filter_new();
gtk_file_filter_add_pattern (GTK_FILE_FILTER(filter_all), "*");
gtk_file_filter_set_name (GTK_FILE_FILTER(filter_all), ("All Files"));
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
dialog = gtk_file_chooser_dialog_new ("Save File", GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE,
GTK_RESPONSE_ACCEPT, NULL);
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER(dialog), "Sin_Nombre.txt");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(dialog), filter_all);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(dialog), filter8);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(dialog), filter32);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
direccion = filename;
fpt = fopen(filename, "w+");
g_assert (GTK_IS_TEXT_VIEW (user_data));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (user_data));
gtk_text_buffer_get_start_iter(GTK_TEXT_BUFFER (buffer), &start);
gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER (buffer), &end);
textin = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(buffer), &start, &end, FALSE);
fprintf (fpt, "%s", textin);
fprintf (fpt, "\n");
fclose (fpt);
saved = 1;
}
gtk_widget_destroy (dialog);
}
else
{
fpt = fopen(direccion, "w+");
g_assert (GTK_IS_TEXT_VIEW (user_data));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (user_data));
gtk_text_buffer_get_start_iter(GTK_TEXT_BUFFER (buffer), &start);
73
gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER (buffer), &end);
textin = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(buffer), &start, &end, FALSE);
fprintf (fpt, "%s", textin);
fprintf (fpt, "\n");
saved = 2;
fclose(fpt);
}
}
void savetemp (GtkWidget *button, gpointer user_data)
// Funcion que muestra un dialogo
{
GtkTextBuffer *buffer;
// Declaracion de "Variables"
GtkTextIter start, end;
gchar *texto;
FILE *fpt;
g_assert (GTK_IS_TEXT_VIEW (user_data));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (user_data));
gtk_text_buffer_get_start_iter(GTK_TEXT_BUFFER (buffer), &start);
gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER (buffer), &end);
if( !gtk_text_iter_equal(&start, &end) )
{
fpt = fopen("Sin_Nombre.txt","w+");
texto = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(buffer), &start, &end, FALSE);
fprintf (fpt, "%s", texto);
fclose(fpt);
}
}
/*-----------------------------------------------------------------------------------*/
/***************************************Menus*****************************************/
/*-----------------------------------------------------------------------------------*/
/*************/
void undo_redo (GtkButton * button, gpointer user_data)
{
GtkTextBuffer *buffer = NULL;
GtkTextIter start, end;
gchar *text;
g_assert (GTK_IS_TEXT_VIEW (user_data));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (user_data));
gtk_text_buffer_get_start_iter(GTK_TEXT_BUFFER (buffer), &start);
gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER (buffer), &end);
text = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(buffer), &start, &end, TRUE);
if(act){
if (un_re)
{
oldtext = text;
un_re = 0;
74
}
else
{
currenttext = text;
un_re = 1;
}
}
act = 1;
}
/*************/
void on_button_undo_clicked (GtkButton * button, gpointer user_data)
{
GtkTextBuffer *buffer = NULL;
g_assert (GTK_IS_TEXT_VIEW (user_data));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (user_data));
act = 0;
if (un_re)
{
gtk_text_buffer_set_text (buffer, oldtext, -1);
un_re = 1;
}
else
{
gtk_text_buffer_set_text (buffer, currenttext, -1);
un_re = 0;
}
redoactivable = 1;
}
/*************/
void on_button_redo_clicked (GtkButton * button, gpointer user_data)
{
GtkTextBuffer *buffer = NULL;
g_assert (GTK_IS_TEXT_VIEW (user_data));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (user_data));
act = 0;
if(redoactivable)
{
if (!un_re)
{
gtk_text_buffer_set_text (buffer, oldtext, -1);
un_re = 1;
}
else
{
gtk_text_buffer_set_text (buffer, currenttext, -1);
un_re = 0;
}
redoactivable = 0;
}
75
}
/*************/
void delete_clicked (GtkButton * button, gpointer user_data)
{
GtkTextBuffer *textbuffer = NULL;
GtkTextIter start, end;
g_assert (GTK_IS_TEXT_VIEW (user_data));
textbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (user_data));
gtk_text_buffer_get_start_iter(GTK_TEXT_BUFFER (textbuffer), &start);
gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER (textbuffer), &end);
gtk_text_buffer_get_bounds (textbuffer, &start, &end);
gtk_text_buffer_delete (textbuffer, &start, &end);
}
/*************/
void clear_clicked (GtkButton * button, gpointer user_data)
{
GtkTextBuffer *textbuffer = NULL;
GtkTextIter start, end;
g_assert (GTK_IS_TEXT_VIEW (user_data));
textbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (user_data));
gtk_text_buffer_get_selection_bounds (textbuffer, &start, &end);
gtk_text_buffer_select_range (textbuffer, &start, &end );
gtk_text_buffer_delete (textbuffer, &start, &end);
}
/*************/
void on_button_cut_clicked (GtkButton * button, gpointer user_data)
{
GtkTextBuffer *textbuffer = NULL;
g_assert (GTK_IS_TEXT_VIEW (user_data));
textbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (user_data));
gtk_text_buffer_cut_clipboard (textbuffer, gtk_clipboard_get (GDK_NONE), TRUE);
}
/*************/
void on_button_copy_clicked (GtkButton * button, gpointer user_data)
{
GtkTextBuffer *textbuffer = NULL;
g_assert (GTK_IS_TEXT_VIEW (user_data));
textbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (user_data));
gtk_text_buffer_copy_clipboard (textbuffer, gtk_clipboard_get (GDK_NONE));
}
/*************/
void on_button_paste_clicked (GtkButton * button, gpointer user_data)
{
GtkTextBuffer *textbuffer = NULL;
g_assert (GTK_IS_TEXT_VIEW (user_data));
textbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (user_data));
gtk_text_buffer_paste_clipboard (textbuffer, gtk_clipboard_get (GDK_NONE), NULL, TRUE);
}
76
/*************/
void on_button_select_clicked (GtkButton * button, gpointer user_data)
{
GtkTextBuffer *textbuffer = NULL;
GtkTextIter start, end;
g_assert (GTK_IS_TEXT_VIEW (user_data));
textbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (user_data));
gtk_text_buffer_get_start_iter(GTK_TEXT_BUFFER (textbuffer), &start);
gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER (textbuffer), &end);
gtk_text_buffer_get_bounds (textbuffer, &start, &end);
gtk_text_buffer_select_range (textbuffer, &start, &end );
}
/*************/
void on_button_mark_clicked (GtkButton * button, gpointer user_data)
reservadas del codigo
{
//Marca las palabaras
GtkTextBuffer *buffer = NULL;
// Buffer de lectura
GtkTextIter start, end;
// Indican la posicion de
la palabra encontrada
GtkTextIter iter, iter2;
// Interactor que indica la posicion
inicial
char valores[10];
// numeros del 0 al 9 como
caracteres
int exit, count, numeros[10], i, v_cpucr;
// Variables de condicion
gboolean founda, foundm, foundw, foundb, foundfm, foundn, foundc, fi;// Para saber si se encontro
la palabra
const char *instrucciones[52], *instrucciones_m[52];
v_cpucr = atoi(versioncpucr);
if(v_cpucr==8)
{
instrucciones[0] = "ADD ";
instrucciones[1] = "AND ";
instrucciones[2] = "BCC";
instrucciones[3] = "BCS";
instrucciones[4] = "BEQ";
instrucciones[5] = "BMI";
instrucciones[6] = "BNE";
instrucciones[7] = "BPL";
instrucciones[8] = "BVC";
instrucciones[9] = "BVS";
instrucciones[10] = "CLA";
instrucciones[11] = "CLC";
instrucciones[12] = "CLI";
instrucciones[13] = "CPA";
instrucciones[14] = "DCA";
instrucciones[15] = "HLT";
instrucciones[16] = "INA";
instrucciones[17] = "INP ";
instrucciones[18] = "JMP ";
77
instrucciones[19] = "JSR ";
instrucciones[20] = "LDA ";
instrucciones[21] = "NOP";
instrucciones[22] = "ORA ";
instrucciones[23] = "OUT ";
instrucciones[24] = "PHA";
instrucciones[25] = "PHS";
instrucciones[26] = "PLA";
instrucciones[27] = "PLS";
instrucciones[28] = "ROL";
instrucciones[29] = "ROR";
instrucciones[30] = "RTI";
instrucciones[31] = "RTS";
instrucciones[32] = "SEC";
instrucciones[33] = "SEI";
instrucciones[34] = "STA ";
instrucciones[35] = "SUB ";
instrucciones[36] = "TAP";
instrucciones[37] = "TPA";
instrucciones_m[0] = "add ";
instrucciones_m[1] = "and ";
instrucciones_m[2] = "bcc";
instrucciones_m[3] = "bcs";
instrucciones_m[4] = "beq";
instrucciones_m[5] = "bmi";
instrucciones_m[6] = "bne";
instrucciones_m[7] = "bpl";
instrucciones_m[8] = "bvc";
instrucciones_m[9] = "bvs";
instrucciones_m[10] = "cla";
instrucciones_m[11] = "clc";
instrucciones_m[12] = "cli";
instrucciones_m[13] = "cpa";
instrucciones_m[14] = "dca";
instrucciones_m[15] = "hlt";
instrucciones_m[16] = "ina";
instrucciones_m[17] = "inp ";
instrucciones_m[18] = "jmp ";
instrucciones_m[19] = "jsr ";
instrucciones_m[20] = "lda ";
instrucciones_m[21] = "nop";
instrucciones_m[22] = "ora ";
instrucciones_m[23] = "out ";
instrucciones_m[24] = "pha";
instrucciones_m[25] = "phs";
instrucciones_m[26] = "pla";
instrucciones_m[27] = "pls";
instrucciones_m[28] = "rol";
instrucciones_m[29] = "ror";
instrucciones_m[30] = "rti";
instrucciones_m[31] = "rts";
instrucciones_m[32] = "sec";
instrucciones_m[33] = "sei";
instrucciones_m[34] = "sta ";
instrucciones_m[35] = "sub ";
78
instrucciones_m[36] = "tap";
instrucciones_m[37] = "tpa";
}
else
{
instrucciones[0] = "ADD ";
instrucciones[1] = "AND ";
instrucciones[2] = "BCC";
instrucciones[3] = "BCS";
instrucciones[4] = "BEQ";
instrucciones[5] = "BMI";
instrucciones[6] = "BNE";
instrucciones[7] = "BPL";
instrucciones[8] = "BVC";
instrucciones[9] = "BVS";
instrucciones[10] = "CLR";
instrucciones[11] = "CLC";
instrucciones[12] = "CLI";
instrucciones[13] = "CPL";
instrucciones[14] = "DEC";
instrucciones[15] = "HLT";
instrucciones[16] = "INC";
instrucciones[17] = "INP ";
instrucciones[18] = "JMP ";
instrucciones[19] = "JSR ";
instrucciones[20] = "LD ";
instrucciones[21] = "NOP";
instrucciones[22] = "ORA ";
instrucciones[23] = "OUT ";
instrucciones[24] = "PH";
instrucciones[25] = "PHS";
instrucciones[26] = "PL";
instrucciones[27] = "PLS";
instrucciones[28] = "ROL";
instrucciones[29] = "ROR";
instrucciones[30] = "RTI";
instrucciones[31] = "RTS";
instrucciones[32] = "SEC";
instrucciones[33] = "SEI";
instrucciones[34] = "ST ";
instrucciones[35] = "SUB ";
instrucciones[36] = "TAP";
instrucciones[37] = "TPA";
instrucciones[38] = "XOR ";
instrucciones[39] = "NAND";
instrucciones[40] = "NOR";
instrucciones[41] = "XNOR";
instrucciones[42] = "ADC";
instrucciones[43] = "SBC";
instrucciones[44] = "TRP";
instrucciones[45] = "TPR";
instrucciones[46] = "BL";
instrucciones[47] = "BLE";
instrucciones[48] = "BG";
instrucciones[49] = "BGE";
79
instrucciones[50] = "BZ";
instrucciones[51] = "BNZ";
instrucciones_m[0] = "add ";
instrucciones_m[1] = "and ";
instrucciones_m[2] = "bcc";
instrucciones_m[3] = "bcs";
instrucciones_m[4] = "beq";
instrucciones_m[5] = "bmi";
instrucciones_m[6] = "bne";
instrucciones_m[7] = "bpl";
instrucciones_m[8] = "bvc";
instrucciones_m[9] = "bvs";
instrucciones_m[10] = "clr";
instrucciones_m[11] = "clc";
instrucciones_m[12] = "cli";
instrucciones_m[13] = "cpl";
instrucciones_m[14] = "dec";
instrucciones_m[15] = "hlt";
instrucciones_m[16] = "inc";
instrucciones_m[17] = "inp ";
instrucciones_m[18] = "jmp ";
instrucciones_m[19] = "jsr ";
instrucciones_m[20] = "ld ";
instrucciones_m[21] = "nop";
instrucciones_m[22] = "or ";
instrucciones_m[23] = "out ";
instrucciones_m[24] = "ph";
instrucciones_m[25] = "phs";
instrucciones_m[26] = "pl";
instrucciones_m[27] = "pls";
instrucciones_m[28] = "rol";
instrucciones_m[29] = "ror";
instrucciones_m[30] = "rti";
instrucciones_m[31] = "rts";
instrucciones_m[32] = "sec";
instrucciones_m[33] = "sei";
instrucciones_m[34] = "st ";
instrucciones_m[35] = "sub ";
instrucciones_m[36] = "tap";
instrucciones_m[37] = "tpa";
instrucciones_m[38] = "xor ";
instrucciones_m[39] = "nand";
instrucciones_m[40] = "xnor";
instrucciones_m[41] = "adc";
instrucciones_m[42] = "sbc";
instrucciones_m[43] = "trp";
instrucciones_m[44] = "tpr";
instrucciones_m[45] = "bl";
instrucciones_m[46] = "ble";
instrucciones_m[47] = "bg";
instrucciones_m[48] = "bge";
instrucciones_m[49] = "bz";
80
instrucciones_m[50] = "bnz";
instrucciones_m[51] = "nor";
}
/*--------------------------------------------------------------------*/
// Recupera e inicializa el buffer de escritura
g_assert (GTK_IS_TEXT_VIEW (user_data));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (user_data));
gtk_text_buffer_get_start_iter (buffer, &iter);
gtk_text_buffer_get_end_iter (buffer, &iter2);
if( !gtk_text_iter_equal(&iter, &iter2) ){
gtk_text_buffer_remove_tag_by_name (buffer, "num", &iter, &iter2);
gtk_text_buffer_remove_tag_by_name (buffer, "word", &iter, &iter2);
gtk_text_buffer_remove_tag_by_name (buffer, "coment", &iter, &iter2);
gtk_text_buffer_remove_tag_by_name (buffer, "instruccion", &iter, &iter2);}
/*--------------------------------------------------------------------*/
exit = 0;
// Encuentra palabra "MACRO"
gtk_text_buffer_get_start_iter (buffer, &iter);
do{
foundm = gtk_text_iter_forward_search (&iter, "MACRO ",
GTK_TEXT_SEARCH_VISIBLE_ONLY, &start, &end, NULL);
if (foundm)
{
gtk_text_buffer_apply_tag_by_name (buffer, "word", &start, &end);
iter=end;
foundm = 0;
}
else
{
exit = 1;
}
}while(exit!=1);
exit = 0;
// Encuentra palabra "macro"
gtk_text_buffer_get_start_iter (buffer, &iter);
do{
foundm = gtk_text_iter_forward_search (&iter, "macro ",
GTK_TEXT_SEARCH_VISIBLE_ONLY, &start, &end, NULL);
if (foundm)
{
gtk_text_buffer_apply_tag_by_name (buffer, "word", &start, &end);
iter=end;
foundm = 0;
}
else
{
exit = 1;
}
}while(exit!=1);
/*--------------------------------------------------------------------*/
exit = 0;
// Encuentra palabra "WRD"
81
gtk_text_buffer_get_start_iter (buffer, &iter);
do{
foundw = gtk_text_iter_forward_search (&iter, " WRD", GTK_TEXT_SEARCH_VISIBLE_ONLY,
&start, &end, NULL);
if (foundw)
{
gtk_text_buffer_apply_tag_by_name (buffer, "word", &start, &end);
iter=end;
foundw = 0;
}
else
{
foundw = gtk_text_iter_forward_search (&iter, "\nWRD",
GTK_TEXT_SEARCH_VISIBLE_ONLY, &start, &end, NULL);
if (foundw)
{
gtk_text_buffer_apply_tag_by_name (buffer, "word", &start, &end);
iter=end;
foundw = 0;
}
else
{
exit = 1;
}
}
}while(exit!=1);
/*--------------------------------------------------------------------*/
exit = 0;
// Encuentra palabra "wrd"
gtk_text_buffer_get_start_iter (buffer, &iter);
do{
foundw = gtk_text_iter_forward_search (&iter, " wrd", GTK_TEXT_SEARCH_VISIBLE_ONLY,
&start, &end, NULL);
if (foundw)
{
gtk_text_buffer_apply_tag_by_name (buffer, "word", &start, &end);
iter=end;
foundw = 0;
}
else
{
foundw = gtk_text_iter_forward_search (&iter, "\nwrd",
GTK_TEXT_SEARCH_VISIBLE_ONLY, &start, &end, NULL);
if (foundw)
{
gtk_text_buffer_apply_tag_by_name (buffer, "word", &start, &end);
iter=end;
foundw = 0;
}
else
{
exit = 1;
}
}
}while(exit!=1);
82
/*--------------------------------------------------------------------*/
exit = 0;
// Encuentra palabra "DBWRD"
gtk_text_buffer_get_start_iter (buffer, &iter);
do{
foundb = gtk_text_iter_forward_search (&iter, "DBWRD", GTK_TEXT_SEARCH_VISIBLE_ONLY,
&start, &end, NULL);
if (foundb)
{
gtk_text_buffer_apply_tag_by_name (buffer, "word", &start, &end);
iter=end;
foundb = 0;
}
else
{
exit = 1;
}
}while(exit!=1);
exit = 0;
// Encuentra palabra "dbwrd"
gtk_text_buffer_get_start_iter (buffer, &iter);
do{
foundb = gtk_text_iter_forward_search (&iter, "dbwrd", GTK_TEXT_SEARCH_VISIBLE_ONLY,
&start, &end, NULL);
if (foundb)
{
gtk_text_buffer_apply_tag_by_name (buffer, "word", &start, &end);
iter=end;
foundb = 0;
}
else
{
exit = 1;
}
}while(exit!=1);
/*--------------------------------------------------------------------*/
exit = 0;
// Encuentra caracter asterisco '*'
gtk_text_buffer_get_start_iter (buffer, &iter);
do{
founda = gtk_text_iter_forward_search (&iter, "*", GTK_TEXT_SEARCH_VISIBLE_ONLY, &start,
&end, NULL);
if (founda)
{
gtk_text_buffer_apply_tag_by_name (buffer, "word", &start, &end);
iter=end;
founda = 0;
}
else
{
exit = 1;
}
}while(exit!=1);
83
/*--------------------------------------------------------------------*/
exit = 0;
// Encuentra caracter dollar '$'
gtk_text_buffer_get_start_iter (buffer, &iter);
do{
founda = gtk_text_iter_forward_search (&iter, "$", GTK_TEXT_SEARCH_VISIBLE_ONLY, &start,
&end, NULL);
if (founda)
{
gtk_text_buffer_apply_tag_by_name (buffer, "num", &start, &end);
iter=end;
founda = 0;
}
else
{
exit = 1;
}
}while(exit!=1);
/*--------------------------------------------------------------------*/
exit = 0;
// Encuentra palabra "FINMAC"
gtk_text_buffer_get_start_iter (buffer, &iter);
do{
foundfm = gtk_text_iter_forward_search (&iter, "FINMAC", GTK_TEXT_SEARCH_VISIBLE_ONLY,
&start, &end, NULL);
if (foundfm)
{
gtk_text_buffer_apply_tag_by_name (buffer, "word", &start, &end);
iter=end;
foundfm = 0;
}
else
{
exit = 1;
}
}while(exit!=1);
exit = 0;
// Encuentra palabra "finmac"
gtk_text_buffer_get_start_iter (buffer, &iter);
do{
foundfm = gtk_text_iter_forward_search (&iter, "finmac", GTK_TEXT_SEARCH_VISIBLE_ONLY,
&start, &end, NULL);
if (foundfm)
{
gtk_text_buffer_apply_tag_by_name (buffer, "word", &start, &end);
iter=end;
foundfm = 0;
}
else
{
exit = 1;
}
84
}while(exit!=1);
/*--------------------------------------------------------------------*/
for (i=0; i<10; i++)
// Encuentra los numeros del texto
{
gtk_text_buffer_get_start_iter (buffer, &iter);
exit = 0;
do {
numeros[i] = i;
sprintf(valores, "%d", numeros[i]);
foundn = gtk_text_iter_forward_search (&iter, valores,
GTK_TEXT_SEARCH_VISIBLE_ONLY, &start, &end, NULL);
if (foundn)
{
gtk_text_buffer_apply_tag_by_name (buffer, "num", &start, &end);
iter=end;
foundn = 0;
}
else
{
exit = 1;
}
}while(exit!=1);
}
/*--------------------------------------------------------------------*/
if(v_cpucr==8)
{
for (i=0; i<38; i++)
// Encuentra instrucciones (MAYUSCULAS)
{
gtk_text_buffer_get_start_iter (buffer, &iter);
exit = 0;
do {
fi = gtk_text_iter_forward_search
(&iter,instrucciones[i],GTK_TEXT_SEARCH_VISIBLE_ONLY,&start,&end,NULL);
if (fi)
{
gtk_text_buffer_apply_tag_by_name (buffer, "instruccion", &start, &end);
iter=end;
fi = 0;
}
else
{
exit = 1;
}
}while(exit!=1);
}
for (i=0; i<38; i++)
// Encuentra instrucciones (minusculas)
{
gtk_text_buffer_get_start_iter (buffer, &iter);
85
exit = 0;
do {
fi = gtk_text_iter_forward_search
(&iter,instrucciones_m[i],GTK_TEXT_SEARCH_VISIBLE_ONLY,&start,&end,NULL);
if (fi)
{
gtk_text_buffer_apply_tag_by_name (buffer, "instruccion", &start, &end);
iter=end;
fi = 0;
}
else
{
exit = 1;
}
}while(exit!=1);
}
}
else
{
for (i=0; i<52; i++)
// Encuentra instrucciones (MAYUSCULAS)
{
gtk_text_buffer_get_start_iter (buffer, &iter);
exit = 0;
do {
fi = gtk_text_iter_forward_search
(&iter,instrucciones[i],GTK_TEXT_SEARCH_VISIBLE_ONLY,&start,&end,NULL);
if (fi)
{
gtk_text_buffer_apply_tag_by_name (buffer, "instruccion", &start, &end);
iter=end;
fi = 0;
}
else
{
exit = 1;
}
}while(exit!=1);
}
for (i=0; i<52; i++)
// Encuentra instrucciones (minusculas)
{
gtk_text_buffer_get_start_iter (buffer, &iter);
exit = 0;
do {
fi = gtk_text_iter_forward_search
(&iter,instrucciones_m[i],GTK_TEXT_SEARCH_VISIBLE_ONLY,&start,&end,NULL);
if (fi)
{
gtk_text_buffer_apply_tag_by_name (buffer, "instruccion", &start, &end);
iter=end;
fi = 0;
}
else
86
{
exit = 1;
}
}while(exit!=1);
}
}
/*--------------------------------------------------------------------*/
exit = 0;
// Encuentra los Comentarios
gtk_text_buffer_get_start_iter (buffer, &iter);
gtk_text_buffer_get_end_iter (buffer, &end);
do{
foundc = gtk_text_iter_forward_search (&iter, ";", GTK_TEXT_SEARCH_VISIBLE_ONLY, &start,
NULL, NULL);
if (foundc)
{
if (gtk_text_iter_forward_search (&start, "\n", GTK_TEXT_SEARCH_VISIBLE_ONLY, NULL,
&end, NULL))
{
gtk_text_buffer_remove_tag_by_name (buffer, "num", &start, &end);
// Quita formato
anterior
gtk_text_buffer_remove_tag_by_name (buffer, "word", &start, &end); // Quita formato anterior
gtk_text_buffer_remove_tag_by_name (buffer, "instruccion", &start, &end); // Quita formato
anterior
gtk_text_buffer_apply_tag_by_name (buffer, "coment", &start, &end); // Coloca formato de
comentario
iter=end;
foundc = 0;
}
else
{
count = gtk_text_buffer_get_char_count (buffer);
gtk_text_buffer_get_iter_at_offset (buffer, &end, count);
gtk_text_buffer_remove_tag_by_name (buffer, "num", &start, &end);
// Quita formato
anterior
gtk_text_buffer_remove_tag_by_name (buffer, "word", &start, &end); // Quita formato anterior
gtk_text_buffer_remove_tag_by_name (buffer, "instruccion", &start, &end); // Quita formato
anterior
gtk_text_buffer_apply_tag_by_name (buffer, "coment", &start, &end); // Coloca formato de
comentario
exit = 1;
}
}
else
{
exit = 1;
}
}while(exit!=1);
}
/*************/
void on_button_bold_clicked (GtkButton * button, gpointer user_data)
{
GtkTextBuffer *textbuffer = NULL;
GtkTextIter start, end;
87
g_assert (GTK_IS_TEXT_VIEW (user_data));
textbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (user_data));
gtk_text_buffer_get_selection_bounds (textbuffer, &start, &end);
gtk_text_buffer_apply_tag_by_name (textbuffer, "bold", &start, &end);
}
/*************/
void on_button_color_clicked (GtkButton * button, gpointer user_data)
{
GtkTextBuffer *textbuffer = NULL;
GtkTextIter start, end;
g_assert (GTK_IS_TEXT_VIEW (user_data));
textbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (user_data));
gtk_text_buffer_get_selection_bounds (textbuffer, &start, &end);
gtk_text_buffer_apply_tag_by_name (textbuffer, "color", &start, &end);
}
/*************/
void on_button_unbold_clicked (GtkButton * button, gpointer user_data)
{
GtkTextBuffer *textbuffer = NULL;
GtkTextIter start, end;
g_assert (GTK_IS_TEXT_VIEW (user_data));
textbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (user_data));
gtk_text_buffer_get_selection_bounds (textbuffer, &start, &end);
gtk_text_buffer_remove_tag_by_name (textbuffer, "bold", &start, &end);
gtk_text_buffer_remove_tag_by_name (textbuffer, "color", &start, &end);
}
/*************/
void create_tags (GtkTextBuffer * buffer)
{
g_assert (GTK_IS_TEXT_BUFFER (buffer));
gtk_text_buffer_create_tag (buffer, "bold", "weight", PANGO_WEIGHT_BOLD, NULL);
gtk_text_buffer_create_tag (buffer, "under", "underline", PANGO_UNDERLINE_SINGLE, NULL);
gtk_text_buffer_create_tag (buffer, "centrar", "justification", GTK_JUSTIFY_CENTER, NULL);
gtk_text_buffer_create_tag (buffer, "color", "foreground", "green", NULL);
gtk_text_buffer_create_tag (buffer, "num", "foreground", "purple", NULL);
gtk_text_buffer_create_tag (buffer, "coment", "foreground", "gray", NULL);
gtk_text_buffer_create_tag (buffer, "instruccion", "weight", PANGO_WEIGHT_BOLD, NULL);
gtk_text_buffer_create_tag (buffer, "word", "foreground", "brown", "weight",
PANGO_WEIGHT_BOLD, NULL);
}
88
/*-----------------------------------------------------------------------------------*/
/**************************************Checks*****************************************/
/*-----------------------------------------------------------------------------------*/
/*************/
void check_button_clicked(GtkButton * button, gpointer user_data)
{
if(gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(user_data)))
{
versioncpucr = "8";
}
else
{
versioncpucr = "32";
}
}
/*************/
void check_button_unclicked(GtkButton * button, gpointer user_data)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(user_data), FALSE);
}
void pressed(GtkButton *button, gpointer user_data)
{
gtk_button_set_focus_on_click (GTK_BUTTON(user_data), TRUE);
}
/*-----------------------------------------------------------------------------------*/
/**************************************Ejecutar***************************************/
/*-----------------------------------------------------------------------------------*/
/*************/
void on_button_compile_clicked (int bits, gpointer user_data)
{
GtkTextBuffer *buffer;
GtkTextIter start;
GtkTextIter end;
char *codigo;
// Variable que toma el codigo
// string str1, str2, str3, str4;
on_button_save_clicked(NULL, user_data);
g_assert (GTK_IS_TEXT_VIEW (user_data));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (user_data));
escrito en el
gtk_text_buffer_get_start_iter(GTK_TEXT_BUFFER (buffer), &start);
como un
// toma el codigo
// editor de texto
89
gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER (buffer), &end);
// char*
especificamente en la
codigo = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(buffer), &start, &end, FALSE); // variable
codigo
/*----------------------------------------------------------------------------------------------*/
if(saved!=5)
{
//
str =
Interfaz Interfaz1;
Interfaz1.setCMPL(direccion, versioncpucr, codigo, P_VM, memoria1, Puerto_entrada,
Puerto_salida, princPila, princPC, princAcum, AuxPila, AuxPC, AuxAcum, princN, princV, princI, princZ,
princC, AuxN, AuxV, AuxI, AuxZ, AuxC);// Aqui le envio el codigo escrito en el editor al objeto
advertencias = Interfaz1.getADV();
// Obtiene Advertencias
proyecto_compilado = Interfaz1.getCompilado();
// Obtiene si el proyecto fue compilado
exitosamente
}
}
/*************/
void on_button_run_clicked (int bits, gpointer user_data)
{
GtkWidget *dialog;
string mem1, mem2, mem3, mem4, mem5, mem6, mem7, mem8;
int vb;
vb = atoi(versioncpucr);
if(!proyecto_compilado)
{
/*----------------------------------------------------------------------------------------------*/
Interfaz Interfaz2;
Interfaz2.setRun(direccion, versioncpucr, 65535, 0, V_M);
mem1 = Interfaz2.getVm1();
// Obtiene la Ventana de memoria
mem2 = Interfaz2.getVm3();
// Obtiene la Ventana de memoria
mem3 = Interfaz2.getVm5();
// Obtiene la Ventana de memoria
mem4 = Interfaz2.getVm7();
// Obtiene la Ventana de memoria
mem5 = Interfaz2.getVm2();
// Obtiene la Ventana de memoria
mem6 = Interfaz2.getVm4();
// Obtiene la Ventana de memoria
mem7 = Interfaz2.getVm6();
// Obtiene la Ventana de memoria
mem8 = Interfaz2.getVm8();
// Obtiene la Ventana de memoria
mem1 = mem1 + mem5;
mem2 = mem2 + mem6;
mem3 = mem3 + mem7;
mem4 = mem4 + mem8;
memoria1 = string_to_char(mem1);
memoria2 = string_to_char(mem2);
memoria3 = string_to_char(mem3);
// Obtiene la Ventana de memoria
// Obtiene la Ventana de memoria
// Obtiene la Ventana de memoria
90
memoria4 = string_to_char(mem4);
// Obtiene la Ventana de memoria
Registro_de_Instrucciones = Interfaz2.getR_I(); // Obtiene el registro de instrucciones
Puerto_entrada = Interfaz2.getPort_IN();
// Obtiene puerto de entrada
Puerto_salida = Interfaz2.getPort_OUT(); // Obtiene puerto de salida
princPila = Interfaz2.getPP();
princPC = Interfaz2.getPCP();
princAcum = Interfaz2.getAP();
AuxPila = Interfaz2.getPA();
AuxPC = Interfaz2.getPCA();
AuxAcum = Interfaz2.getAA();
princN = Interfaz2.getNP();
princV = Interfaz2.getVP();
princI = Interfaz2.getIP();
princZ = Interfaz2.getZP();
princC = Interfaz2.getCP();
AuxN = Interfaz2.getNA();
AuxV = Interfaz2.getVA();
AuxI = Interfaz2.getIA();
AuxZ = Interfaz2.getZA();
AuxC = Interfaz2.getCA();
// Obtiene Pila principal
// Obtiene PC principal
// Obtiene Acumulador principal
// Obtiene Pila Auxiliar
// Obtiene PC Auxiliar
// Obtiene Acumulador Auxiliar
// Obtiene N principal
// Obtiene V principal
// Obtiene I principal
// Obtiene Z principal
// Obtiene Z principal
// Obtiene N Auxiliar
// Obtiene V Auxiliar
// Obtiene I Auxiliar
// Obtiene Z Auxiliar
// Obtiene C Auxiliar
Registros Registros1;
// Crea el objeto Registros
Registros1.Ventana(vb, user_data, direccion, princPila, princPC, princAcum, AuxPila, AuxPC,
AuxAcum,
princN, princV, princI, princZ, princC,
AuxN, AuxV,
AuxI, AuxZ, AuxC,
memoria1, memoria2, memoria3, memoria4, Puerto_entrada,
Puerto_salida);
// Le envia el texto recibido en la linea anterior
/*----------------------------------------------------------------------------------------------*/
}
else
{
dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, //Lo que imprime la
ventana de informacion
GTK_MESSAGE_INFO,
GTK_BUTTONS_CLOSE,
"\n\nDebe Compilar Exitosamente el Proyecto Antes de
Ejecutarlo!!");
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER); // Posicion de
la ventana de dialogo
gtk_dialog_run (GTK_DIALOG (dialog));
// Corre el dialogo
gtk_widget_destroy (dialog);
}
}
/***************************************************************************************
****************************************************************************************
91
************************************ Fin De main *****************************************
****************************************************************************************
***************************************************************************************/
92
Archivo Editor.cpp
// Copyright (c) 2009 Universidad de Costa Rica, Escuela de Ingenieria Eléctrica
// Author: Jairo Alberto Roldán Morales
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
/*********************************************************************************/
/*********************************************************************************/
/*********************************** Inicio Editor ***********************************/
/*********************************************************************************/
/*********************************************************************************/
#include <gtk/gtk.h>
#include <gdk/gdk.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <time.h>
#include <ctype.h>
#include "Registros.h"
#include "Editor.h"
#include "Interfaz.h"
#define SIZE_MAX 5000
#define SIZEV 620
#define SIZEH 500
// Incluir librerias
void cerrar(GtkWidget *widget,gpointer *data);
// Inicializar funciones
void creditos (GtkWidget *wid, GtkWidget *win);
void confirmation(GtkWidget *button, gpointer user_data);
void guardar (char *nombre, gpointer user_data);
void abrir (char *nombre, gpointer user_data);
void on_button_open_clicked (GtkButton * button, gpointer user_data);
void on_button_save_clicked (GtkButton * button, gpointer user_data);
void on_button_save_as_clicked (GtkButton * button, gpointer user_data);
void savetemp (GtkWidget *button, gpointer user_data);
void undo_redo (GtkButton * button, gpointer user_data);
void on_button_undo_clicked (GtkButton * button, gpointer user_data);
void on_button_redo_clicked (GtkButton * button, gpointer user_data);
93
void delete_clicked (GtkButton * button, gpointer user_data);
void clear_clicked (GtkButton * button, gpointer user_data);
void on_button_cut_clicked (GtkButton * button, gpointer user_data);
void on_button_copy_clicked (GtkButton * button, gpointer user_data);
void on_button_paste_clicked (GtkButton * button, gpointer user_data);
void on_button_select_clicked (GtkButton * button, gpointer user_data);
void on_button_mark_clicked (GtkButton * button, gpointer user_data);
void insertion();
void on_button_bold_clicked (GtkButton * button, gpointer user_data);
void on_button_color_clicked (GtkButton * button, gpointer user_data);
void on_button_unbold_clicked (GtkButton * button, gpointer user_data);
void on_button_compile_clicked (int bits, gpointer user_data);
void warnings_changed (int bits, gpointer user_data);
void on_button_run_clicked (int bits, gpointer user_data);
void check_button_clicked(GtkButton * button, gpointer user_data);
void check_button_unclicked(GtkButton * button, gpointer user_data);
void pressed(GtkButton *button, gpointer user_data);
void on_button_vm_clicked (GtkButton * button, gpointer user_data);
void create_tags (GtkTextBuffer *buffer);
char *string_to_char(string in);
/*------------------------------------------------------------------------*/
/*--------------------------Creacion del Editor---------------------------*/
/*------------------------------------------------------------------------*/
void Editor::win(int bits, gpointer user_data, char* advertencias){ // Clase que conecta el editor
this->
create (bits, user_data, advertencias);
};
GtkWidget *numero_de_linea;
GtkTextBuffer *buffer_editor;
void Editor::create (int bits, gpointer user_data, char* advertencias)
{
//Declaracion de Variables GTK
GtkWidget *window, *cajav, *cajah, *menu_bar; // Elementos de la Ventana Principal
GtkWidget *inf, *dialog, *check1, *check2;
// Casillas de verificacion para seleccionar 8 o 32 bits
GtkWidget *menu_file, *file, *open, *save, *save_as, *quit; // Elementos del menu Archivo
GtkWidget *menu_edit, *edit, *cut, *copy, *paste; // Elementos del menu Edicion
GtkWidget *button_undo, *button_redo, *limpiar; // Boton deshacer, rehacer, y limpiar ventana
GtkWidget *menu_format, *format, *color, *bold, *unbold, *sel_all; // Elementos del menu Formato
GtkWidget *menu_debug, *debug, *compile, *run; // Elementos del menu Ejecutar
GtkWidget *menu_acerca_de, *acerca_de, *credits; // Elementos del menu Acerca de
GtkWidget *handlemenu, *handlebox, *handlelabel; // Barras de menu, de herramientas y de checks
GtkWidget *toolbar;
GtkWidget *button_cut,*button_copy,*button_paste; // Boton cortar, copiar y pegar
GtkWidget *button_open, *button_save;
// Boton Abrir y Guardar
94
GtkWidget *button_compile, *button_run;
// Boton Compilar y Ejecutar
GtkWidget *text, *scrolledwindow;
GtkWidget *warnings, *scrolled_war;
GtkTextBuffer *bufferw;
// Ventana de Texto
// Ventana de advertencias
// Buffer para el texto mostrado y escrito
/****************Ventana Principal*******************/
window =
gtk_window_new(GTK_WINDOW_TOPLEVEL);
// Ventana principal
gtk_window_set_title (GTK_WINDOW (window), "Ensamblador de la CPRUCR para 8 y 32 bits"); //
Titulo de la ventana
gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER); // Posicion de la
ventana como centrada
gtk_window_set_default_size (GTK_WINDOW(window), SIZEH, SIZEV); // Dimensiones "DEFAULT"
de la ventana
gtk_container_set_resize_mode (GTK_CONTAINER(window), GTK_RESIZE_IMMEDIATE);
gtk_container_resize_children (GTK_CONTAINER(window));
gtk_container_set_reallocate_redraws (GTK_CONTAINER(window), FALSE);
cajav =
gtk_vbox_new(FALSE, 0);
// Caja vertical para colocar la barra de menu, herramientas, texto,
checks
gtk_container_add(GTK_CONTAINER(window), cajav); // la caja esta contenida en la ventana
gtk_container_set_resize_mode (GTK_CONTAINER(cajav), GTK_RESIZE_IMMEDIATE);
gtk_container_resize_children (GTK_CONTAINER(cajav));
gtk_container_set_reallocate_redraws (GTK_CONTAINER(cajav), TRUE);
handlemenu =
gtk_handle_box_new ();
gtk_box_pack_start (GTK_BOX (cajav), handlemenu, FALSE, FALSE, 0);
gtk_widget_set_usize(GTK_WIDGET (handlemenu), NULL, 28);
/****************Menu File*******************/
menu_bar =
// Creacion de la barra de menu
gtk_menu_bar_new();
gtk_container_add(GTK_CONTAINER(handlemenu), menu_bar);
menu_file =
gtk_menu_new();
// Se crea un menu (Archivo)
file =
gtk_menu_item_new_with_label("Archivo");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), menu_file);
gtk_menu_bar_append(GTK_MENU_BAR (menu_bar), file);
open =
gtk_menu_item_new_with_label("Abrir");
// Items del menu Archivo
95
gtk_menu_append(GTK_MENU(menu_file), open);
save =
gtk_menu_item_new_with_label("Guardar");
gtk_menu_append(GTK_MENU(menu_file), save);
save_as =
gtk_menu_item_new_with_label("Guardar como");
gtk_menu_append(GTK_MENU(menu_file), save_as);
quit =
gtk_menu_item_new_with_label("Salir");
gtk_menu_append(GTK_MENU(menu_file), quit);
/****************Menu Edit*******************/
menu_edit =
gtk_menu_new();
// Se crea un menu (Edicion)
edit =
gtk_menu_item_new_with_label("Edicion");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(edit), menu_edit);
gtk_menu_bar_append(GTK_MENU_BAR (menu_bar), edit);
button_undo =
gtk_menu_item_new_with_label("Undo");
gtk_menu_append(GTK_MENU(menu_edit), button_undo);
button_redo =
gtk_menu_item_new_with_label("Redo");
gtk_menu_append(GTK_MENU(menu_edit), button_redo);
sel_all =
gtk_menu_item_new_with_label("Seleccionar todo");
gtk_menu_append(GTK_MENU(menu_edit), sel_all);
limpiar =
gtk_menu_item_new_with_label("Limpiar Ventana");
gtk_menu_append(GTK_MENU(menu_edit), limpiar);
cut =
// Items del menu Edicion
gtk_menu_item_new_with_label("Cortar");
gtk_menu_append(GTK_MENU(menu_edit), cut);
copy =
gtk_menu_item_new_with_label("Copiar");
gtk_menu_append(GTK_MENU(menu_edit), copy);
paste =
gtk_menu_item_new_with_label("Pegar");
gtk_menu_append(GTK_MENU(menu_edit), paste);
96
/****************Menu Format*******************/
menu_format =
gtk_menu_new();
// Se crea un menu (Formato)
format =
gtk_menu_item_new_with_label("Formato");
// Items del menu Formato
gtk_menu_item_set_submenu(GTK_MENU_ITEM(format), menu_format);
gtk_menu_bar_append(GTK_MENU_BAR (menu_bar), format);
color =
gtk_menu_item_new_with_label("Color (verde)");
gtk_menu_append(GTK_MENU(menu_format), color);
bold =
gtk_menu_item_new_with_label("Negrita");
gtk_menu_append(GTK_MENU(menu_format), bold);
unbold =
gtk_menu_item_new_with_label("Borrar Formato");
gtk_menu_append(GTK_MENU(menu_format), unbold);
/****************Menu Debug*******************/
menu_debug =
gtk_menu_new();
// Se crea un menu (Ejecutar)
debug =
gtk_menu_item_new_with_label("Ejecutar");
// Items del menu Ejecutar
gtk_menu_item_set_submenu(GTK_MENU_ITEM(debug), menu_debug);
gtk_menu_bar_append(GTK_MENU_BAR (menu_bar), debug);
compile =
gtk_menu_item_new_with_label("Compilar");
gtk_menu_append(GTK_MENU(menu_debug), compile);
run =
gtk_menu_item_new_with_label("Ejecutar");
gtk_menu_append(GTK_MENU(menu_debug), run);
/****************Menu Acerca de...*******************/
menu_acerca_de =
gtk_menu_new();
// Se crea un menu (Acerca de...)
acerca_de =
// Items del menu Acerca de...
gtk_menu_item_new_with_label("Acerca de---");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(acerca_de), menu_acerca_de);
gtk_menu_bar_append(GTK_MENU_BAR (menu_bar), acerca_de);
97
credits =
gtk_menu_item_new_with_label("Creditos");
gtk_menu_append(GTK_MENU(menu_acerca_de), credits);
/*************Barra de herramientas**********/
handlebox =
gtk_handle_box_new ();
gtk_box_pack_start (GTK_BOX (cajav), handlebox, FALSE, FALSE, 0);
gtk_widget_set_usize(GTK_WIDGET (handlebox), NULL, 65);
toolbar =
gtk_toolbar_new ();
gtk_container_add (GTK_CONTAINER (handlebox), toolbar);
// Items de la barra de herramientas
button_open = gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar), "gtk-open", "Abrir", "Abrir", NULL,
NULL, -1);
button_save = gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar), "gtk-save", "Guardar", "Guardar",
NULL, NULL, -1);
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
button_cut = gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar), "gtk-cut", "Cortar", "Cortar", NULL,
NULL, -1);
button_copy = gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar), "gtk-copy", "Copiar", "Copiar",
NULL, NULL, -1);
button_paste = gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar), "gtk-paste", "Pegar", "Pegar", NULL,
NULL, -1);
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar)); // Espacio entre Items
button_compile = gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar), "gtk-ok", "Compilar", "Compilar",
NULL, NULL, -1);
button_run = gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar), "gtk-execute", "Ejecutar", "Ejecutar",
NULL, NULL, -1);
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar)); // Espacio entre Items
/****************Ventana de scroll y Texto*******************/
scrolledwindow =
// Ventana con scroll
gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (cajav), scrolledwindow, TRUE, TRUE, 0);
text =
gtk_text_view_new ();
// Texto y buffer del texto
gtk_container_add (GTK_CONTAINER (scrolledwindow), text);
buffer_editor =
gtk_text_view_get_buffer (GTK_TEXT_VIEW (text));
create_tags (buffer_editor);
handlelabel =
gtk_handle_box_new ();
gtk_box_pack_start (GTK_BOX (cajav), handlelabel, FALSE, FALSE, 0);
gtk_widget_set_usize(GTK_WIDGET (handlelabel), NULL, 28);
98
cajah =
gtk_hbox_new(FALSE, 10);
gtk_container_add(GTK_CONTAINER(handlelabel), cajah);
inf =
// Etiqueta con texto
gtk_label_new("Seleccione la cantidad de bits: ");
gtk_container_add(GTK_CONTAINER(cajah), inf);
check1 =
gtk_check_button_new_with_label ("8 Bits");// Boton de check para seleccinar 8 bits
gtk_container_add(GTK_CONTAINER(cajah), check1);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(check1), TRUE); // Por default, 8 bits estara
activo
check2 =
gtk_check_button_new_with_label ("32 Bits");// Boton de check para seleccinar 32 bits
gtk_container_add(GTK_CONTAINER(cajah), check2);
numero_de_linea =
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(cajah), numero_de_linea);
scrolled_war =
// Ventana para los warnigs
gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (cajav), scrolled_war, FALSE, FALSE, 0);
gtk_widget_set_usize(GTK_WIDGET (scrolled_war), NULL, 75);
warnings =
gtk_text_view_new ();
// Texto y buffer para los warnings
gtk_container_add (GTK_CONTAINER (scrolled_war), warnings);
gtk_widget_set_usize(GTK_WIDGET (warnings), NULL, 75);
bufferw =
gtk_text_view_get_buffer (GTK_TEXT_VIEW (warnings));
gtk_text_buffer_set_text (bufferw, "Warnigs...", -1);
/******************************Conectar elementos a Funciones*******************************/
g_signal_connect ((gpointer) window, "destroy", G_CALLBACK (cerrar), NULL);
g_signal_connect ((gpointer) quit, "activate", G_CALLBACK (confirmation), (gpointer) text);
g_signal_connect ((gpointer) credits, "activate", G_CALLBACK (creditos), NULL);
g_signal_connect ((gpointer) open, "activate", G_CALLBACK (on_button_open_clicked), (gpointer) text);
g_signal_connect ((gpointer) save, "activate", G_CALLBACK (on_button_save_clicked), (gpointer) text);
g_signal_connect ((gpointer) save_as, "activate", G_CALLBACK (on_button_save_as_clicked), (gpointer)
text);
g_signal_connect ((gpointer) cut, "activate", G_CALLBACK (on_button_cut_clicked), (gpointer) text);
g_signal_connect ((gpointer) copy, "activate", G_CALLBACK (on_button_copy_clicked), (gpointer) text);
g_signal_connect ((gpointer) paste, "activate", G_CALLBACK (on_button_paste_clicked), (gpointer)
text);
g_signal_connect ((gpointer) button_undo, "activate",G_CALLBACK
(on_button_undo_clicked),(gpointer) text);
g_signal_connect ((gpointer) button_redo, "activate",G_CALLBACK (on_button_redo_clicked),(gpointer)
text);
99
g_signal_connect ((gpointer) sel_all, "activate",G_CALLBACK (on_button_select_clicked),(gpointer)
text);
g_signal_connect ((gpointer) limpiar, "activate",G_CALLBACK (delete_clicked),(gpointer) text);
g_signal_connect ((gpointer) color, "activate",G_CALLBACK (on_button_color_clicked),(gpointer) text);
g_signal_connect ((gpointer) bold, "activate",G_CALLBACK (on_button_bold_clicked),(gpointer) text);
g_signal_connect ((gpointer) unbold, "activate",G_CALLBACK (on_button_unbold_clicked),(gpointer)
text);
g_signal_connect ((gpointer) compile, "activate", G_CALLBACK (on_button_compile_clicked), (gpointer)
text);
g_signal_connect ((gpointer) compile, "activate", G_CALLBACK (warnings_changed), (gpointer)
warnings);
g_signal_connect ((gpointer) run, "activate", G_CALLBACK (on_button_run_clicked), (gpointer) text);
g_signal_connect ((gpointer) button_open, "clicked", G_CALLBACK (on_button_open_clicked),
(gpointer) text);
g_signal_connect ((gpointer) button_save, "clicked", G_CALLBACK (on_button_save_clicked), (gpointer)
text);
g_signal_connect ((gpointer) button_cut, "clicked", G_CALLBACK (on_button_cut_clicked), (gpointer)
text);
g_signal_connect ((gpointer) button_copy, "clicked", G_CALLBACK (on_button_copy_clicked),
(gpointer) text);
g_signal_connect ((gpointer) button_paste, "clicked", G_CALLBACK (on_button_paste_clicked),
(gpointer) text);
g_signal_connect ((gpointer) button_compile, "clicked", G_CALLBACK (on_button_compile_clicked),
(gpointer) text);
g_signal_connect ((gpointer) button_compile, "released", G_CALLBACK (warnings_changed), (gpointer)
warnings);
g_signal_connect ((gpointer) button_run, "clicked", G_CALLBACK (on_button_run_clicked), (gpointer)
text);
g_signal_connect ((gpointer) button_run, "clicked", G_CALLBACK (pressed), (gpointer) button_run);
g_signal_connect ((gpointer) check1, "released", G_CALLBACK (check_button_unclicked), (gpointer)
check2);
g_signal_connect ((gpointer) check1, "clicked", G_CALLBACK (check_button_clicked), (gpointer)
check1);
g_signal_connect ((gpointer) check2, "released", G_CALLBACK (check_button_unclicked), (gpointer)
check1);
g_signal_connect ((gpointer) check2, "clicked", G_CALLBACK (check_button_clicked), (gpointer)
check1);
g_signal_connect ((gpointer) check1, "released", G_CALLBACK (on_button_mark_clicked), (gpointer)
text);
g_signal_connect ((gpointer) check2, "released", G_CALLBACK (on_button_mark_clicked), (gpointer)
text);
g_signal_connect ((gpointer) buffer_editor, "changed", G_CALLBACK
(on_button_mark_clicked),(gpointer) text);
g_signal_connect ((gpointer) buffer_editor, "changed", G_CALLBACK (undo_redo),(gpointer) text);
g_signal_connect ((gpointer) buffer_editor, "changed", G_CALLBACK (savetemp),(gpointer) text);
gtk_timeout_add (200, (GtkFunction)insertion, NULL);
/**************************Finalizacion del programa****************************/
gtk_widget_show_all (window);
widgets de la ventana
// Muestra todos los
100
dialog = gtk_message_dialog_new (GTK_WINDOW (window), GTK_DIALOG_MODAL,
GTK_MESSAGE_INFO, // Mensaje inicial
GTK_BUTTONS_CLOSE, "BIENVENIDO!!!\n\nSimulador de la CPUCR para 8 bits y 32 bits");//Lo que
imprime la ventana de informacion
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER);
// Posicion de la
ventana de dialogo
gtk_dialog_run (GTK_DIALOG (dialog));
// Corre el dialogo
gtk_widget_destroy (dialog);
}
void insertion()
{
char s[3], *c;
int i;
string str, etiqueta;
GtkTextIter start, end, iter;
gtk_text_buffer_get_start_iter(GTK_TEXT_BUFFER (buffer_editor), &start);
gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER (buffer_editor), &end);
gtk_text_buffer_get_selection_bounds (buffer_editor, &iter, NULL);
etiqueta = "Nº Linea: ";
i = 1 + gtk_text_iter_get_line (&iter);
sprintf(s, "%d", i);
str = (string)s;
str = etiqueta + str;
c = string_to_char(str);
gtk_label_set_text (GTK_LABEL(numero_de_linea), c);
gtk_label_set_justify (GTK_LABEL(numero_de_linea), GTK_JUSTIFY_LEFT);
}
101
Archivo Interfaz.cpp
// Copyright (c) 2009 Universidad de Costa Rica, Escuela de Ingenieria Eléctrica
// Author: Jairo Alberto Roldán Morales
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
/***************************************************************************************
****************************************************************************************
**************************Etapa de Compilación y simulacion*********************************
****************************************************************************************
***************************************************************************************/
#include "Registros.h"
// Cabeceras de codigo
#include "Editor.h"
#include "Interfaz.h"
#include "compiler.hh"
#include "memory.hh"
#include "simulator.hh" // Agregado
#include "registers.hh" // Agregado
#include <string.h>
// Librerias
#include <string>
#include <gtk/gtk.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <ctype.h>
#define TAMANO 16
// Utilizado para las pruebas, se puede eliminar
#define SIZE_VM 65536
// Tamaño de la ventana de memoria, debe ser de 65536
int ranum();
// Metodo que genera un numero binario aleatorio del tipo int
int random_num();
// Metodo que genera un numero aleatorio del tipo int
char *randoble();
// Metodo que genera un numero aleatorio del tipo char*
char *ran();
// Metodo que genera un numero binario aleatorio del tipo char*
string randstring2();
// Metodo que genera un numero aleatorio del tipo string
char *string_to_char(string in);// Metodo que convierte de string a char*
int temp;
/*---------------------------------------------------------------------------------------------------------*/
/*--------------------------------Clase que Compila y obtiene los resultados-------------------------------*/
/*---------------------------------------------------------------------------------------------------------*/
102
void Interfaz::setCMPL(char* ruta, const char* version, char* codigo, int posicion, char* mem, const
char*Pto_ent,
const char*Pto_sal, char*Ppila, char*Ppc, char*Pacum, char*Apila, char*Apc,
char*Aacum,
char*pN, char*pV, char*pI, char*pZ, char*pC, char*aN, char*aV, char*aI, char*aZ,
char*aC)
// Recibir datos a compilar
{// Ruta del archivo, Version de la CPUCR, Codigo fuente, Posicion donde se interrumpe el
programa
char *mensaje;
int vb;
// Utilizada para devolver Warnings, que son del tipo char*
// Version de bits de la CPUCR (8 o 32)
/*-----------------------------------------------------------------------------------------------------------------*/
compiler compilador;
memory memoria;
compilador.set_memory(&memoria);
compilador.parse(string (ruta) );
/*-----------------------------------------------------------------------------------------------------------------*/
this -> compilado = compilador.check_errors();// Programa pudo o no ser compilado
exitosamente
mensaje = string_to_char (compilador.error_to_window);
this -> Adv = mensaje;
// Toma los errores y los envia a Adv
/*-------------------------------------------------------------------------------*/
/*-----------------Descomentar esto con los nombres correctos--------------------*/
/*-------------------------------------------------------------------------------*/
/* Nombre_clase_Simuladora Objeto1;
// Crea el objeto para compilar
*/
/* Objeto1.Nombre_del_Metodo(ruta, vb, Interrupcion, ....);
/*
*/
*/
/* this -> Posicion_vm = Objeto1.Nombre_del_Metodo_que_retorna_variable_vm();
*/
/* this -> Port_in = Objeto1.Nombre_del_Metodo_que_retorna_variable_Port_in();
*/
/* this -> Port_out = Objeto1.Nombre_del_Metodo_que_retorna_variable_Port_out();*/
/*
.
.
.
*/
/*
.
.
.
/*
.
.
.
*/
*/
/* this -> Cp = Objeto1.Nombre_del_Metodo_que_retorna_variable_Cp();
*/
103
/* this -> Ca = Objeto1.Nombre_del_Metodo_que_retorna_variable_Ca();
*/
/*-------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------*/
//Eliminar a partir de esta seccion:
/**/
this -> Port_in = randoble();
/**/
this -> Port_out = randoble();
/**/
/**/
this -> Pp = randoble();
// Pila
/**/
this -> Pa = randoble();
/**/
this -> PCp = randoble();
/**/
this -> PCa = randoble();
/**/
this -> Ap = randoble();
/**/
this -> Aa = randoble();
/**/
/**/
this -> Np = ran();
/**/
this -> Na = ran();
/**/
this -> Vp = ran();
/**/
this -> Va = ran();
/**/
this -> Ip = ran();
/**/
this -> Ia = ran();
/**/
this -> Zp = ran();
/**/
this -> Za = ran();
/**/
this -> Cp = ran();
/**/
this -> Ca = ran();
/**///Fin de seleccion a eliminar
}
// Puerto de entrada
// Puerto de salida
// Contador de programa
// Acumulador
// Banderas de Estado
/*---------------------------------------------------------------------------------------------------------*/
/*-----------------------Clase que Ejecuta el programa y obtiene la ventana de memoria---------------------*/
/*---------------------------------------------------------------------------------------------------------*/
void Interfaz::setRun(char* ruta, const char* version, int posicion_final, int interrumpir_ejecucion, string
VALOR_V_M)
{
char *regs, *n, *v, *I, *z, *c, *flag;
int i, vb, nn, vv, ii, zz,cc;
string strS, space, dollar, equis, inp_memory, pos_memory, vector[65536];
string Registro_de_estado, get_flag_str;
string str1, str2, str3, str4, str5, str6, str7, str8;
string nuevo1, nuevo2, nuevo3, nuevo4, nuevo5, nuevo6, nuevo7, nuevo8;
FILE *fpt;
vb = atoi(version);
strS="\n";
space="
";
dollar="$";
equis="x";
nuevo1="";
nuevo2="";
nuevo3="";
nuevo4="";
// vb es un int que indica la version de la CPUCR (8 o 32)
104
compiler compilador2;
memory memoria2;
simulator sim; // Agregado se crea el objeto simulador
registers reg; // Agregado se crea el objeto de registros
compilador2.set_memory(&memoria2);
sim.set_memory (&memoria2); // Agregado se le pasa la memoria al simulador
sim.set_registers (&reg); // Agregado sele pasan los registros al simualdor
compilador2.parse( string(ruta) );
temp = 0;
for(i=0; i<SIZE_VM; i++)
{
pos_memory = compilador2.convert_to_string(i, 16, 4);
inp_memory = memoria2.read_memory(pos_memory);
if(inp_memory!=equis)
{
vector[i] = dollar+pos_memory+space+dollar+inp_memory+strS;
temp = i+1;
}
else
{
vector[i] = dollar+pos_memory+space+randstring2()+strS;
}
}
for(i=0; i<(SIZE_VM/8); i++)
{
str1 = nuevo1 + vector[i];
nuevo1 = str1;
str2 = nuevo2 + vector[i+(SIZE_VM/8)];
nuevo2 = str2;
str3 = nuevo3 + vector[i+2*(SIZE_VM/8)];
nuevo3 = str3;
str4 = nuevo4 + vector[i+3*(SIZE_VM/8)];
nuevo4 = str4;
str5 = nuevo5 + vector[i+4*(SIZE_VM/8)];
nuevo5 = str5;
str6 = nuevo6 + vector[i+5*(SIZE_VM/8)];
nuevo6 = str6;
str7 = nuevo7 + vector[i+6*(SIZE_VM/8)];
nuevo7 = str7;
str8 = nuevo8 + vector[i+7*(SIZE_VM/8)];
nuevo8 = str8;
}
this -> vm1 = str1;
this -> vm2 = str2;
this -> vm3 = str3;
this -> vm4 = str4;
this -> vm5 = str5;
this -> vm6 = str6;
this -> vm7 = str7;
this -> vm8 = str8;
// Ventana de memoria
105
if(posicion_final==65535)
{
sim.run_simulation( "0" , "0000");
}
else
{
sim.run_simulation( "1", ( compilador2.convert_to_string(posicion_final, 16, 4)
) );
}
this -> Pp = string_to_char(dollar+reg.pp_read()); // Recibe Pila
this -> PCp = string_to_char(dollar+reg.pc_read());
// Recibe Contador de
programa
this -> Ap = string_to_char(dollar+reg.ac_read()); // Recibe Acumulador
/**/
/**/
this -> Port_in = randoble();
this -> Port_out = randoble();
/**/
/**/
/**/
this -> Pa = randoble();
this -> PCa = randoble();
this -> Aa = randoble();
// Puerto de entrada
// Puerto de salida
this -> R_I = string_to_char(reg.ri_read());
/*
Registro_de_estado = reg.rs_read();
regs = string_to_char(Registro_de_estado);
fpt = fopen("status", "w+");
fprintf (fpt, "%s", regs);
fclose(fpt);
fpt = fopen("status", "r");
for(i=0; i<8; i++)
{
get_flag_str = getc(fpt);
flag = string_to_char(get_flag_str);
switch(i)
{
case 2:
n = flag;
break;
case 4:
v = flag;
break;
case 5:
I = flag;
break;
case 6:
z = flag;
break;
106
case 7:
c = flag;
break;
default:
break;
}
}
fclose(fpt);
*/
n = string_to_char( reg.bn_read() );
v = string_to_char( reg.bv_read() );
I = string_to_char( reg.bi_read() );
z = string_to_char( reg.bz_read() );
c = string_to_char( reg.bc_read() );
this -> Np = n;
this -> Vp = v;
this -> Ip = I;
this -> Zp = z;
this -> Cp = c;
/**/
/**/
/**/
/**/
/**/
// Banderas de Estado
this -> Na = ran();
this -> Va = ran();
this -> Ia = ran();
this -> Za = ran();
this -> Ca = ran();
}
/*---------------------------------------------------------------------------------------------------------*/
/*--------------------------Clase que Ejecuta paso a paso y obtiene los resultados-------------------------*/
/*---------------------------------------------------------------------------------------------------------*/
void Interfaz::setStep(char* ruta, const char* version, int Interrupcion, int Pos_VM) // Recibir datos para
compilar paso a paso
{// Ruta del archivo, Version de la CPUCR, Solicitud de interrumpir el programa ("1"
interrumpe)
char *mensaje;
const char *error="Hubo errores en la compilacion"; // Warning opcional, indica No Exito
const char *exito="Compilacion realizada exitosamente"; // Warning opcional, indica Exito
int vb;
string strT, str[32], strS="\n";
str[0]="$0000
";
str[1]="$0001
";
str[2]="$0002
";
str[3]="$0003
";
str[4]="$0004
";
str[5]="$0005
";
str[6]="$0006
";
str[7]="$0007
";
str[8]="$0008
";
str[9]="$0009
";
str[10]="$000a
";
// Seccion de pruebas, se puede eliminar
//
//
//
//
//
//
//
//
//
//
//
107
str[11]="$000b
str[12]="$000c
str[13]="$000d
str[14]="$000e
str[15]="$000f
str[16]="$0010
str[17]="$0011
str[18]="$0012
str[19]="$0013
str[20]="$0014
str[21]="$0015
str[22]="$0016
str[23]="$0017
str[24]="$0018
str[25]="$0019
str[26]="$001a
str[27]="$001b
str[28]="$001c
str[29]="$001d
str[30]="$001e
str[31]="$001f
";
";
";
";
";
";
";
";
";
";
";
";
";
";
";
";
";
";
";
";
";
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// Fin de seccion de pruebas
vb = atoi(version);
/*-------------------------------------------------------------------------------*/
/*-----------------Descomentar esto con los nombres correctos--------------------*/
/*-------------------------------------------------------------------------------*/
/* Nombre_clase_Simuladora Objeto1;
// Crea el objeto para compilar
*/
/* Objeto1.Nombre_del_Metodo(ruta, vb, Interrupcion);
*/
/*
*/
/* this -> compilado = Objeto1.Nombre_del_Metodo_que_retorna_variable_1();
*/
/* this -> Posicion_vm = Objeto1.Nombre_del_Metodo_que_retorna_variable_2();
*/
/* this -> Adv = Objeto1.Nombre_del_Metodo_que_retorna_variable_3();
*/
/*
.
.
.
/*
.
.
.
/*
.
.
.
*/
*/
*/
/* this -> Cp = Objeto1.Nombre_del_Metodo_que_retorna_variable_n-1();
*/
/* this -> Ca = Objeto1.Nombre_del_Metodo_que_retorna_variable_n();
*/
/*-------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------*/
compiler compilador2;
memory memoria2;
108
simulator sim; // Agregado se crea el objeto simulador
registers reg; // Agregado se crea el objeto de registros
compilador2.set_memory(&memoria2);
sim.set_memory (&memoria2); // Agregado se le pasa la memoria al simulador
sim.set_registers (&reg); // Agregado sele pasan los registros al simualdor
compilador2.parse( string(ruta) );
//
sim.run_simulation("2","0000");
/**///Eliminar a partir de esta seccion:
/**/
this -> compilado = ranum(); // Programa pudo o no ser compilado exitosamente
/**///Fin de seleccion a eliminar
/*Warnings Opcionales*/
/**/
if (compilado)
/**/
{
/**/
mensaje = (char*)exito;
/**/
}
/**/
/**/
else
/**/
{
/**/
mensaje = (char*)error;
/**/
}
/*Fin de Warnings Opcionales*/
/**///Eliminar a partir de esta seccion:
/**/
this -> posicion_vm = random_num();// Futuramente: this -> posicion_vm =
random_num()%vb;
/**/
this -> Adv = mensaje;
// Toma la direccion del archivo y lo almacena en Adv
/**/
/**/
strT=str[posicion_vm]+randstring2()+strS;
/**/
this -> vm1 = strT;
// Ventana de memoria
/**/
this -> Port_in = randoble();
// Puerto de entrada
/**/
this -> Port_out = randoble(); // Puerto de salida
/**/
/**/
this -> Pp = randoble();
// Pila
/**/
this -> Pa = randoble();
/**/
this -> PCp = randoble();
// Contador de programa
/**/
this -> PCa = randoble();
/**/
this -> Ap = randoble();
// Acumulador
/**/
this -> Aa = randoble();
/**/
/**/
this -> Np = ran();
// Banderas de Estado
/**/
this -> Na = ran();
/**/
this -> Vp = ran();
/**/
this -> Va = ran();
/**/
this -> Ip = ran();
/**/
this -> Ia = ran();
/**/
this -> Zp = ran();
/**/
this -> Za = ran();
109
/**/
this -> Cp = ran();
/**/
this -> Ca = ran();
/**///Fin de seleccion a eliminar
}
/*---------------------------------------------------------------------------------------------------------*/
/*-------------------------------Clases que Devuelven los registros y memoria------------------------------*/
/*----------------------------------No modificar, funcionan perfectamente----------------------------------*/
/*---------------------------------------------------------------------------------------------------------*/
int Interfaz::getCompilado(){
return this->compilado;}
int Interfaz::getPosicion_VM(){
return this->posicion_vm;}
string Interfaz::getVm1() {
return this->vm1;}
// Recuperar Ventana de memoria
string Interfaz::getVm2() {
return this->vm2;}
// Recuperar Ventana de memoria
string Interfaz::getVm3() {
return this->vm3;}
// Recuperar Ventana de memoria
string Interfaz::getVm4() {
return this->vm4;}
// Recuperar Ventana de memoria
string Interfaz::getVm5() {
return this->vm5;}
// Recuperar Ventana de memoria
string Interfaz::getVm6() {
return this->vm6;}
// Recuperar Ventana de memoria
string Interfaz::getVm7() {
return this->vm7;}
// Recuperar Ventana de memoria
string Interfaz::getVm8() {
return this->vm8;}
// Recuperar Ventana de memoria
char* Interfaz::getADV(){
return this->Adv;}
// Obtiene las Advertencias si las hay
char* Interfaz::getPort_IN(){
return this->Port_in;}
// Recuperar valor del puerto de entrada
char* Interfaz::getPort_OUT(){
return this->Port_out;}
char* Interfaz::getR_I() {
return this->R_I;}
// Recuperar valor del puerto de salida
// Devuelve el registro de instrucciones
110
char* Interfaz::getPP() {
return this->Pp;}
// Recuperar Pila
char* Interfaz::getPA(){
return this->Pa;}
char* Interfaz::getPCP(){
return this->PCp;}
// Recuperar PC
char* Interfaz::getPCA(){
return this->PCa;}
char* Interfaz::getAP(){
return this->Ap;}
// Recuperar Acumulador
char* Interfaz::getAA(){
return this->Aa;}
/*--------------Devuelve las banderas de estado---------------*/
char* Interfaz::getNP(){
return this->Np;}
// N
char* Interfaz::getNA(){
return this->Na;}
char* Interfaz::getVP(){
return this->Vp;}
// V
char* Interfaz::getVA(){
return this->Va;}
char* Interfaz::getIP(){
return this->Ip;}
// I
char* Interfaz::getIA(){
return this->Ia;}
char* Interfaz::getZP(){
return this->Zp;}
// Z
char* Interfaz::getZA(){
return this->Za;}
char* Interfaz::getCP(){
return this->Cp;}
// C
char* Interfaz::getCA(){
return this->Ca;}
/*---------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------Metodos--------------------------------------------------*/
/*---------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------*/
char *string_to_char(string in) // Convierte un string en un char*
111
{
char *s;
s = strdup(in.c_str());
return s;
}
/*--------------------------------------------*/
char *randoble()
//Genera 4 numeros aleatorios
{
char *s;
const char *prueba;
int num;
num = rand();
num = num % TAMANO;
switch (num)
{
case 0:
prueba = "$0000";
break;
case 1:
prueba = "$0001";
break;
case 2:
prueba = "$0002";
break;
case 3:
prueba = "$0003";
break;
case 4:
prueba = "$0004";
break;
case 5:
prueba = "$0005";
break;
case 6:
prueba = "$0006";
break;
case 7:
prueba = "$0007";
break;
case 8:
prueba = "$0008";
break;
112
case 9:
prueba = "$0009";
break;
case 10:
prueba = "$000a";
break;
case 11:
prueba = "$000b";
break;
case 12:
prueba = "$000c";
break;
case 13:
prueba = "$000d";
break;
case 14:
prueba = "$000e";
break;
case 15:
prueba = "$000f";
break;
}
s = (char*)prueba;
return s;
}
/*--------------------------------------------*/
char *ran()
// Genera 1 numero aleatorio
{
char *s;
const char *c;
int num;
num = rand();
num = num % 2;
if(num){
c = "1";}
else{
c = "0";}
s = (char*)c;
return s;
}
/*--------------------------------------------*/
int ranum()
// Genera 1 numero binario aleatorio
113
{
int num;
num = rand();
num = num % 2;
return num;
}
/*--------------------------------------------*/
int random_num()
// Genera 1 numero aleatorio entre 0 y 31
{
int num;
num = rand();
num = num % 32;
return num;
}
string randstring2()
{
string prueba;
int num;
num = rand();
num = num % TAMANO;
switch (num)
{
case 0:
prueba = "$00";
break;
case 1:
prueba = "$01";
break;
case 2:
prueba = "$02";
break;
case 3:
prueba = "$03";
break;
case 4:
prueba = "$04";
break;
case 5:
prueba = "$05";
break;
case 6:
// Genera 1 string aleatorio de 4 caracteres
114
prueba = "$06";
break;
case 7:
prueba = "$07";
break;
case 8:
prueba = "$08";
break;
case 9:
prueba = "$09";
break;
case 10:
prueba = "$0A";
break;
case 11:
prueba = "$0B";
break;
case 12:
prueba = "$0C";
break;
case 13:
prueba = "$0D";
break;
case 14:
prueba = "$0E";
break;
case 15:
prueba = "$0F";
break;
}
return prueba;
}
/***************************************************************************************
****************************************************************************************
************************** Fin De Etapa de Compilación y simulacion **************************
****************************************************************************************
***************************************************************************************/
115
Archivo Registros.cpp
// Copyright (c) 2009 Universidad de Costa Rica, Escuela de Ingenieria Eléctrica
// Author: Jairo Alberto Roldán Morales
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
/***************************************************************************************
****************************************************************************************
**********************************Ventana de Registros*************************************
****************************************************************************************
***************************************************************************************/
#include "Registros.h"
#include "Editor.h"
#include "Interfaz.h"
#include "compiler.hh"
#include <string.h>
#include <gtk/gtk.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define CH 500
#define SIZEV 610
#define SIZEH 780
#define SIZEVM 130
columna
#define MAX_VALUE 10
permitidas en la V.M.
// Libreria "Estandar" GTK
// Libreria para funciones basicas de C
// Tamaño del texto
void salidas(GtkWidget *wid, GtkWidget *win);
void close (GtkWidget *widget, gpointer *data);
void close_win (GtkWidget *wid, GtkWidget *win);
void close_regs (GtkWidget *wid, GtkWidget *win);
void creditos (GtkWidget *wid, GtkWidget *win);
void confirmation(GtkWidget *button, gpointer user_data);
void guardado (GtkWidget *win, gpointer user_data);
void on_button_save_clicked (GtkButton * button, gpointer user_data);
void on_button_stop (GtkButton * button, gpointer user_data);
void on_button_stop_point (GtkButton * button, gpointer user_data);
// Tamaño Vertical de la ventana
// Tamaño Horizontal de la ventana
// Tamaño maximo horizontal para
// Tamaño maximo de constantes
// Funciones a utilizar
116
void on_button_stop_position (GtkButton * button, gpointer user_data);
void on_button_select_clicked (GtkButton * button, gpointer user_data);
void delete_clicked (GtkButton * button, gpointer user_data);
void clear_clicked (GtkButton * button, gpointer user_data);
void on_button_cut_clicked (GtkButton * button, gpointer user_data);
void on_button_copy_clicked (GtkButton * button, gpointer user_data);
void on_button_paste_clicked (GtkButton * button, gpointer user_data);
void on_button_compile (GtkButton * button, gpointer user_data);
void on_button_step_clicked (GtkButton * button, gpointer user_data);
void on_button_run (GtkButton * button, gpointer user_data);
void on_button_mark_clicked (GtkButton * button, gpointer user_data);
void create_tags (GtkTextBuffer *buffer);
void changed_values(GtkButton * button, gpointer user_data);
void changed_vm(GtkButton * button, gpointer user_data);
void on_button_compile_clicked (int bits, gpointer user_data);
void warnings_changed (int bits, gpointer user_data);
void on_button_vm_clicked (GtkButton * button, gpointer user_data);
void marcar (GtkTextIter prueba, gpointer user_data);
void add_const (GtkButton * button, gpointer user_data);
void remove_const (GtkButton * button, gpointer user_data);
void clear_const (GtkButton * button, gpointer user_data);
char *string_to_char(string in);
/***************************************************************************************
*********************
**********************************Clase que crea la Ventana de
Registros*************************************
****************************************************************************************
********************/
void Registros::Ventana(int bits, gpointer user_data, char *dire, char *ppP, char *cpP, char *aaP, char *ppA,
char *cpA,
char *aaA, char *nnp, char *vvp, char *iip, char *zzp, char *ccp, char *nna, char
*vva, char *iia,
char *zza, char *cca, char* vvmm1, char* vvmm2, char* vvmm3, char* vvmm4,
char* pp_in, char* pp_out)
{//tipo de retorno,nombre de la clase::metodo(char,int)
this->
create_window (bits, user_data, dire, ppP, cpP, aaP, ppA, cpA, aaA, nnp, vvp, iip, zzp, ccp,
nna, vva, iia, zza, cca, vvmm1, vvmm2, vvmm3, vvmm4,
pp_in, pp_out);
}; // Crea la ventana de registros con los datos recibidos
/*--------------------------------------------Variables Globales-------------------------------------------*/
char *RprincPila, *RprincPC, *RprincAcum;
char *RAuxPila, *RAuxPC, *RAuxAcum;
char *RprincN, *RprincV, *RprincI, *RprincZ, *RprincC;
char *RAuxN, *RAuxV, *RAuxI, *RAuxZ, *RAuxC;
char *Radvertencias, *Rdireccion;
char *ventana_de_memoria1, *ventana_de_memoria2, *ventana_de_memoria3, *ventana_de_memoria4;
char *registro_de_instrucciones;
117
const char *puerto_in = "0000";
const char *puerto_out = "0000";
int Rversioncpucr = 8;
int v_activa=0, vm_closed=0, Pos_VM=65535;
int Rproyecto_compilado;
int marcas_de_posicion[MAX_VALUE], linea=0;
int vm_created = 0;
int Detener=0, To_posicion=0;
int primer_step=0;
string VALOR_V_M = "$0000";
GtkWidget *text;
GtkWidget *constantes;
GtkTextBuffer *buffervm;
GtkTextBuffer *bufferconst;
// Texto de la ventana de memoria
// Buffer para la ventana de memoria
GtkTextBuffer *buff = NULL;
GtkTextBuffer *bufferP[4];
GtkTextBuffer *bufferA[4];
GtkTextBuffer *buffer_instrucciones;
// Buffer para las variables
// Buffer para los registros principales
// Buffer para los registros Auxiliares
// Buffer para el registro de instruccciones
GtkWidget *textoP[4];
GtkWidget *textoA[4];
GtkWidget *texto_instrucciones;
GtkWidget *entryP[5];
GtkWidget *entryA[5];
GtkWidget *puertos[2];
// Texto de los registros Principales
// Texto de los registros Auxiliares
// Texto para el registro de instrucciones
// Para las banderas de estado Reg. Princ.
// Para las banderas de estado Reg. Aux.
// Para los puertos de la CPUCR
/***/
Interfaz Interfaz2;
/***************************************************************************************
*********************
*******************************************Codigo
Registros**************************************************
****************************************************************************************
********************/
void Registros::create_window (int bits, gpointer user_data, char*dire, char*ppP, char*cpP, char*aaP,
char*ppA, char*cpA,
char*aaA, char*nnp, char*vvp, char*iip, char*zzp, char*ccp, char*nna, char*vva,
char*iia,
char*zza, char*cca, char* vvmm1, char* vvmm2, char* vvmm3, char* vvmm4,
char* pp_in, char* pp_out)
{
GtkWidget *window, *notebook, *page1, *page2, *page3;// Declaracion de "Variables" de gtk
GtkWidget *tab1, *tab2, *tab3, *boxv, *boxA, *box_tab3;
GtkWidget *cajav, *caja_v1, *caja_v2, *caja_v3, *caja_h, *caja_h2, *caja_h3; // Cajas Reg. Princ.
GtkWidget *caja_v1A, *caja_v2A, *caja_v3A, *caja_hA, *caja_h2A, *caja_h3A; // Cajas Reg. Aux.
GtkWidget *space_left, *space_right, *spaceh, *spacev;
GtkWidget *Flags, *ven_vm, *ven_vmA;
GtkWidget *label_pila, *label_status, *label_acum, *label_pc, *label_reg; // Etiquetas Reg. Princ.
GtkWidget *label_pilaA, *label_statusA, *label_acumA, *label_pcA, *label_regA; // Etiquetas Reg. Aux.
GtkWidget *bit, *label_bits, *label_bits2;
118
GtkWidget *menu_bar;
GtkWidget *menu_file, *file, *save, *quit;
GtkWidget *menu_edit, *edit, *copy, *cut, *borrar_sel, *borrar_reg;
GtkWidget *menu_ver, *ver, *memoria, *puertos;
GtkWidget *menu_acerca_de, *acerca_de, *credits;
GtkWidget *scrolledwindowP, *scrolledwindowPC, *scrolledwindowreg; // Ventanas de Scroll Reg. Princ.
GtkWidget *scrolledwindowPA, *scrolledwindowPCA, *scrolledwindowregA; // Ventanas de Scroll Reg.
Aux.
GtkWidget *scrolledwindowinstrucciones;
GtkWidget *handlemenu, *handlebox;
GtkWidget *toolbar;
GtkWidget *button_mem;
GtkWidget *button_save;
GtkWidget *button_delete;
GtkWidget *button_clear;
GtkWidget *button_cut;
GtkWidget *button_copy;
GtkWidget *button_compile;
GtkWidget *button_run;
GtkWidget *button_next;
GtkWidget *button_quit;
// Barra de herramientas
// Boton Ventana de memoria
// Boton guardar
// Boton borrar
// Boton limpiar
// Boton cortar
// Boton copiar
// Boton Compilar
// Boton Ejecutar
// Boton Siguiente
// Boton Salir
GtkTextIter start, end, nstart, nend;
GtkTextIter iter;
// Indican la posicion de la palabra encontrada
// Interactor que indica la posicion inicial
gchar *a, *b, *cc, *d;
gchar *cpyvar;
gboolean founda, foundm, foundw, foundb;
// Texto introducido
int i, num;
int exit, count;
double total;
char nvizc[2];
char num_bits[2];
// Para saber si se encontro la palabra
// Variables de condicion
/*------------------------------------------------------------------------------------------*/
/*----------------------------------Condiciones Iniciales-----------------------------------*/
/*------------------------------------------------------------------------------------------*/
if(bits == 8){
total = pow(2, 8);}
else {
total = pow(2, 32);
}
Rversioncpucr = bits;
Rproyecto_compilado = 1;
vm_created = 0;
ventana_de_memoria1 = vvmm1;
ventana_de_memoria2 = vvmm2;
ventana_de_memoria3 = vvmm3;
ventana_de_memoria4 = vvmm4;
puerto_in = pp_in;
puerto_out = pp_out;
119
Rdireccion = dire;
RprincPila = ppP;
RprincPC = cpP;
RprincAcum = aaP;
RprincN = nnp;
RprincV = vvp;
RprincI = iip;
RprincZ = zzp;
RprincC = ccp;
RAuxPila = ppA;
RAuxPC = cpA;
RAuxAcum = aaA;
RAuxN = nna;
RAuxV = vva;
RAuxI = iia;
RAuxZ = zza;
RAuxC = cca;
/*------------------------------------------------------------------------------------------*/
/*-----------------------------------Creacion de Ventana------------------------------------*/
/*------------------------------------------------------------------------------------------*/
window =
gtk_window_new (GTK_WINDOW_TOPLEVEL);
// Crea la Ventana de Registros
gtk_window_set_title(GTK_WINDOW(window),"Registros CPUCR");
// Titulo de la ventana
gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER); // Posicion de la
ventana
gtk_widget_set_usize(GTK_WIDGET (window), SIZEH, SIZEV);
// Tamaño de la ventana
gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
// Bloquear las dimensiones de la
ventana
cajav =
gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), cajav);
handlemenu =
gtk_handle_box_new ();
gtk_box_pack_start (GTK_BOX (cajav), handlemenu, FALSE, FALSE, 0);
gtk_widget_set_usize(GTK_WIDGET (handlemenu), SIZEH, 28);
/****************Menu File*******************/
menu_bar =
menu
gtk_menu_bar_new();
gtk_container_add(GTK_CONTAINER(handlemenu), menu_bar);
gtk_widget_set_usize(GTK_WIDGET (menu_bar), SIZEH, 30);
menu_file =
gtk_menu_new();
// Creacion de la barra de
120
file =
// Menu Archivo
gtk_menu_item_new_with_label("Archivo");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), menu_file);
gtk_menu_bar_append(GTK_MENU_BAR (menu_bar), file);
save =
gtk_menu_item_new_with_label("Guardar Registros");
gtk_menu_append(GTK_MENU(menu_file), save);
// Item Salir
quit =
gtk_menu_item_new_with_label("Salir");
gtk_menu_append(GTK_MENU(menu_file), quit);
// Item Salir
/****************Menu Edit*******************/
menu_edit =
gtk_menu_new();
edit =
// Menu Edicion
gtk_menu_item_new_with_label("Edicion");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(edit), menu_edit);
gtk_menu_bar_append(GTK_MENU_BAR (menu_bar), edit);
copy =
gtk_menu_item_new_with_label("Copiar");
gtk_menu_append(GTK_MENU(menu_edit), copy);
// Item Copiar
cut =
gtk_menu_item_new_with_label("Cortar");
gtk_menu_append(GTK_MENU(menu_edit), cut);
// Item Cortar
borrar_sel =
gtk_menu_item_new_with_label("Borrar Seleccion");
gtk_menu_append(GTK_MENU(menu_edit), borrar_sel);
// Item borrar seleccion
borrar_reg =
gtk_menu_item_new_with_label("Borrar Todos los Registros");
gtk_menu_append(GTK_MENU(menu_edit), borrar_reg);
// Item borrar regstros
/********************Menu Ver************************/
menu_ver =
gtk_menu_new();
ver =
// Menu Acerca de...
gtk_menu_item_new_with_label("Ver");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(ver), menu_ver);
gtk_menu_bar_append(GTK_MENU_BAR (menu_bar), ver);
memoria =
gtk_menu_item_new_with_label("Ventana de Memoria");
gtk_menu_append(GTK_MENU(menu_ver), memoria);
// Item Creditos
121
puertos =
gtk_menu_item_new_with_label("Puertos");
gtk_menu_append(GTK_MENU(menu_ver), puertos);
// Item Creditos
/****************Menu Acerca de...*******************/
menu_acerca_de =
gtk_menu_new();
acerca_de =
// Menu Acerca de...
gtk_menu_item_new_with_label("Acerca de...");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(acerca_de), menu_acerca_de);
gtk_menu_bar_append(GTK_MENU_BAR (menu_bar), acerca_de);
credits =
gtk_menu_item_new_with_label("Creditos");
gtk_menu_append(GTK_MENU(menu_acerca_de), credits);
// Item Creditos
/*********************************** Barra de Herramientas*******************************/
handlebox =
gtk_handle_box_new ();
gtk_box_pack_start (GTK_BOX (cajav), handlebox, FALSE, FALSE, 0);
gtk_widget_set_usize(GTK_WIDGET (handlebox), SIZEH, 65);
toolbar =
gtk_toolbar_new ();
gtk_container_add (GTK_CONTAINER (handlebox), toolbar);
gtk_widget_set_usize(GTK_WIDGET (toolbar), SIZEH, 65);
// Items de la barra de herramientas
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
// button_undo = gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar), "gtk-undo", NULL, NULL, NULL,
NULL, -1);
button_mem = gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar), "V. M.", "Ventana de Memoria",
NULL, NULL, NULL, -1);
button_save = gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar), "gtk-save", "Guardar Registros",
"Pegar", NULL, NULL, -1);
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar)); // Espacio entre Items
button_delete = gtk_toolbar_insert_stock(GTK_TOOLBAR (toolbar), "gtk-delete","Borrar Ventana","Borrar
Ventana",NULL,NULL,-1);
button_clear = gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar), "gtk-clear", "Borrar Selccion", "Borrar
Seleccion", NULL, NULL, -1);
button_cut = gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar), "gtk-cut", "Cortar", "Cortar", NULL,
NULL, -1);
button_copy = gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar), "gtk-copy", "Copiar", "Copiar",
NULL, NULL, -1);
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar)); // Espacio entre Items
button_compile = gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar), "gtk-ok", "Compilar", "Compilar",
NULL, NULL, -1);
button_run = gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar), "gtk-execute", "Ejecutar", "Ejecutar",
122
NULL, NULL, -1);
button_next = gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar), "gtk-goforward","Siguiente","Siguiente",NULL,NULL,-1);
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar)); // Espacio entre Items
button_quit = gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar), "gtk-quit", "Salir", "Salir", NULL,
NULL, -1);
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar)); // Espacio entre Items
/*-----------------------------Creacion de pestañas----------------------------------*/
page1 = gtk_label_new("Registros");
page2 = gtk_label_new("Registro Destino");
page3 = gtk_label_new("Registro de Instrucciones");
tab1 = gtk_frame_new ("Fuente");
tab2 = gtk_frame_new ("Destino");
tab3 = gtk_frame_new ("Instrucciones");
notebook =
gtk_notebook_new ();
gtk_container_add (GTK_CONTAINER (cajav), notebook);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), tab1, page1);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), tab2, page2);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), tab3, page3);
if(Rversioncpucr != 8){
gtk_notebook_set_tab_label_text(GTK_NOTEBOOK (notebook), tab1, "Registro
Principal");
gtk_notebook_set_tab_label_text(GTK_NOTEBOOK (notebook), tab2, "Registro
Auxiliar");
gtk_frame_set_label (GTK_FRAME(tab1), "Principal");
gtk_frame_set_label (GTK_FRAME(tab2), "Auxiliar");
box_tab3 =
gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(tab3), box_tab3);
scrolledwindowinstrucciones =
// Crea una ventana de scroll para el
registro de inst.
gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (box_tab3), scrolledwindowinstrucciones, FALSE,
FALSE, 0);
texto_instrucciones =
// Coloca un editor de texto en la
ventana
gtk_text_view_new ();
// de scroll
gtk_container_add (GTK_CONTAINER (scrolledwindowinstrucciones),
texto_instrucciones);
buffer_instrucciones =
// Crea un buffer para el texto
gtk_text_view_get_buffer (GTK_TEXT_VIEW (texto_instrucciones));
}
else
123
{
gtk_notebook_remove_page (GTK_NOTEBOOK (notebook), 1);
box_tab3 =
gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(tab3), box_tab3);
scrolledwindowinstrucciones =
// Crea una ventana de scroll para el registro
de inst.
gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (box_tab3), scrolledwindowinstrucciones, FALSE, FALSE, 0);
texto_instrucciones =
// Coloca un editor de texto en la ventana
gtk_text_view_new ();
// de scroll
gtk_container_add (GTK_CONTAINER (scrolledwindowinstrucciones), texto_instrucciones);
buffer_instrucciones =
// Crea un buffer para el texto
gtk_text_view_get_buffer (GTK_TEXT_VIEW (texto_instrucciones));
}
/*-----------------------------------------------------------------------------------*/
/*--------------------------------Ventana Principal----------------------------------*/
/*-----------------------------------------------------------------------------------*/
/****************Creacion de columnas****************/
boxv =
gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(tab1), boxv);
caja_h =
// Creacionde una caja vertical sin espaciamiento
gtk_hbox_new(FALSE, 0);
// la cual es la caja "principal"
gtk_container_add(GTK_CONTAINER(boxv), caja_h);
// se incluye en la ventana principal
space_left =
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(caja_h),space_left);
la ventana
// Coloca un espacio izquierdo en
caja_v1 =
// Creacion de caja vertical con espaciamiento
gtk_vbox_new(FALSE, 4);
// de 4, la cual va montada en la
gtk_container_add(GTK_CONTAINER(caja_h), caja_v1);
// caja principal en la primera
posicion vertical
gtk_widget_set_usize(GTK_WIDGET (caja_v1), SIZEVM, 420);
// que va a ser la primera
columna
spaceh =
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(caja_h),spaceh);
la columna
// Coloca un espacio horizontal en
caja_v2 =
// Creacion de una segunda caja vertical con
gtk_vbox_new(FALSE, 0);
// espaciamiento 4 entre
botones
gtk_container_add(GTK_CONTAINER(caja_h), caja_v2);
// que va en la segunda posicion de
la ventana
124
gtk_widget_set_usize(GTK_WIDGET (caja_v2), SIZEVM, 440);
columna)
spaceh =
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(caja_h),spaceh);
// vertical (segunda
// Coloca el boton en la ventana
caja_v3 =
// Creacion de una segunda caja horizontal con
gtk_vbox_new(FALSE, 10);
// espaciamiento 4 entre
botones
gtk_container_add(GTK_CONTAINER(caja_h), caja_v3);
// que va en la tercera
columna vertical
gtk_widget_set_usize(GTK_WIDGET (caja_v3), SIZEVM, 350);
space_right =
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(caja_h),space_right);
// Coloca el espacio en la ventana
/***********************************************************/
/*********************Primera Columna***********************/
spacev =
vertical
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(caja_v1),spacev);
// Crea un espaciamiento
// Coloca el espacio en la columna
label_pila =
// Detalles de la etiqueta
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(caja_v1),label_pila);
// Coloca la etiqueta en la columna
gtk_widget_set_usize(GTK_WIDGET (label_pila), SIZEVM, 20);
gtk_label_set_markup (GTK_LABEL (label_pila), "<b>PILA</b>");
// La etiqueta dice "PILA"
en negrita
scrolledwindowP =
// Crea una ventana de
scroll para la pila
gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (caja_v1), scrolledwindowP, FALSE, FALSE, 0);
gtk_widget_set_usize(GTK_WIDGET (scrolledwindowP), SIZEVM, 185);
textoP[0] =
// Coloca un editor de texto
en la ventana
gtk_text_view_new ();
// de scroll
gtk_container_add (GTK_CONTAINER (scrolledwindowP), textoP[0]);
gtk_widget_set_usize(GTK_WIDGET (textoP[0]), SIZEVM, 140);
bufferP[0] =
texto
gtk_text_view_get_buffer (GTK_TEXT_VIEW (textoP[0]));
// Crea un buffer para el
spacev =
vertical
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(caja_v1),spacev);
spacev =
// Crea un espaciamiento
// Coloca el espacio en la columna
// Crea un espaciamiento
125
vertical
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(caja_v1),spacev);
// Coloca el espacio en la columna
label_status =
// Detalles del boton
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(caja_v1),label_status);
// Coloca la etiqueta en la ventana
gtk_widget_set_usize(GTK_WIDGET (label_status), SIZEVM, 20);
gtk_label_set_markup (GTK_LABEL (label_status), "<b>BANDERAS DE ESTADO</b>");
Flags =
// Crea una etiqueta
gtk_label_new("N
V
I
Z
C");
// con el texto N V I Z C en la parte superior
gtk_container_add(GTK_CONTAINER(caja_v1),Flags);
// Lo coloca en la caja vertical
caja_h2 =
// Crea una caja horizontal
gtk_hbox_new(TRUE, 0);
// sin espaciamiento entre objetos de la caja
gtk_container_add(GTK_CONTAINER(caja_v1),caja_h2);
for(i=0; i<5; i++)
{
num = rand();
num = num % 2;
// Prueba para asignar valores binarios a cada
// bandera de estado
// Elige un numero al azar
// toma el residuo de dividirlo por 2 (solo
// puede ser 1 o 0)
sprintf(nvizc, "%d", num);
// Convierte entero a char*
entryP[i] = gtk_entry_new_with_max_length (1);
// Define cada espacio para cada
flag
gtk_entry_set_text (GTK_ENTRY(entryP[i]),nvizc);
// con el contenido de la cadena nvizc
gtk_container_add(GTK_CONTAINER(caja_h2), entryP[i]);
la caja
gtk_widget_show_all (caja_h2);
}
// lo coloca en la parte inferior de
// vertical
// Muestra todos los elementos
spacev =
vertical
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(caja_v1),spacev);
// Crea un espaciamiento
// Coloca el espacio en la columna
/*********************Segunda Columna***********************/
label_pc =
// Detalles de la etiqueta
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(caja_v2),label_pc);
// Coloca la etiqueta en la segunda
columna
gtk_widget_set_usize(GTK_WIDGET (label_pc), 200, 20);
gtk_label_set_markup (GTK_LABEL (label_pc), "<b>CONTADOR DE \n PROGRAMA</b>");
scrolledwindowPC =
// Crea una ventan de
Scroll parel PC
gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (caja_v2), scrolledwindowPC, FALSE, FALSE, 0);
textoP[1] =
gtk_text_view_new ();
// Creaccion de un texto editable para el PC
126
gtk_container_add (GTK_CONTAINER (scrolledwindowPC), textoP[1]);
gtk_widget_set_usize(GTK_WIDGET (textoP[1]), SIZEVM, 300);
bufferP[1] =
PC
gtk_text_view_get_buffer (GTK_TEXT_VIEW (textoP[1]));
// Crea un buffer para el
caja_h3 =
// Creacion de una caja horizontal
gtk_hbox_new(FALSE, 0);
// en la tercera columna
gtk_container_add(GTK_CONTAINER(caja_v2), caja_h3);
label_bits =
version
gtk_label_new("Version de");
gtk_container_add(GTK_CONTAINER(caja_h3), label_bits);
sprintf(num_bits, "%d", bits);
// Etiquetqa que muestra la
// con la que se esta trabajando
// Convierte de int a char*
bit =
// Detalles de la etiqueta bits
gtk_label_new(num_bits);
bits: 8 o 32
gtk_container_add(GTK_CONTAINER(caja_h3), bit);
label_bits2 =
gtk_label_new("Bits");
Version de XX Bits
gtk_container_add(GTK_CONTAINER(caja_h3), label_bits2);
columna
// muestra la cantidad de
// Completa la oracion:
// que se muestra en la tercera
/*********************Tercera Columna***********************/
spacev =
vertical
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(caja_v3),spacev);
// Crea un espaciamiento
// Coloca el espacio en la columna
label_acum =
// Detalles de la etiqueta que dice
gtk_label_new(NULL);
gtk_widget_set_usize(GTK_WIDGET (label_acum), 100, 20);
gtk_container_add(GTK_CONTAINER(caja_v3),label_acum);
gtk_label_set_markup (GTK_LABEL (label_acum), "<b>ACUMULADOR</b>"); // "Acumulador" en
negrita
textoP[2] =
// Crea una linea de texto para mostrar el Acum.
gtk_text_view_new ();
gtk_container_add (GTK_CONTAINER (caja_v3), textoP[2]);
gtk_widget_set_usize(GTK_WIDGET (textoP[2]), 40, 20);
bufferP[2] =
Acumulador
gtk_text_view_get_buffer (GTK_TEXT_VIEW (textoP[2]));
// Crea un buffer parael
127
spacev =
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(caja_v3),spacev);
ven_vm =
gtk_button_new_with_label("Ver Ventana de Memoria");
gtk_container_add(GTK_CONTAINER(caja_v3), ven_vm);
spacev =
vertical
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(caja_v3),spacev);
// Coloca un espacio vertical en la
// tercera columna
// Boton para ver la ventana de memoria
// Crea un espaciamiento
// Coloca el espacio en la columna
label_reg =
// Detalles de la etiqueta que dice
gtk_label_new(NULL);
gtk_widget_set_usize(GTK_WIDGET (label_reg), 100, 20);
gtk_container_add(GTK_CONTAINER(caja_v3),label_reg);
gtk_label_set_markup (GTK_LABEL (label_reg), "<b>Variables</b>"); // "Variables" en negrita
scrolledwindowreg =
// Crea una ventan de
Scroll parel PC
gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (caja_v3), scrolledwindowreg, FALSE, FALSE, 0);
textoP[3] =
// Crea una linea de texto para mostrar el Acum.
gtk_text_view_new ();
gtk_container_add (GTK_CONTAINER (scrolledwindowreg), textoP[3]);
gtk_widget_set_usize(GTK_WIDGET (textoP[3]), 60, 160);
bufferP[3] =
Acumulador
gtk_text_view_get_buffer (GTK_TEXT_VIEW (textoP[3]));
// Crea un buffer parael
spacev =
vertical
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(caja_v3),spacev);
// Crea un espaciamiento
// lo colocaen la tercera columna
/*-----------------------------------------------------------------------------------*/
/*---------------------------------Ventana Auxiliar----------------------------------*/
/*-----------------------------------------------------------------------------------*/
if(Rversioncpucr!=8)
{
/****************Creacion de columnas****************/
boxA =
gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(tab2), boxA);
caja_hA =
gtk_hbox_new(FALSE, 0);
// Creacionde una caja vertical sin espaciamiento
// la cual es la caja "principal"
128
gtk_container_add(GTK_CONTAINER(boxA), caja_hA);
principal
space_left =
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(caja_hA),space_left);
la ventana
// se incluye en la ventana
// Coloca un espacio izquierdo en
caja_v1A =
// Creacion de caja vertical con espaciamiento
gtk_vbox_new(FALSE, 4);
// de 4, la cual va montada en la
gtk_container_add(GTK_CONTAINER(caja_hA), caja_v1A);
// caja principal en la primera
posicion vertical
gtk_widget_set_usize(GTK_WIDGET (caja_v1A), SIZEVM, 420);
// que va a ser la primera
columna
spaceh =
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(caja_hA),spaceh);
la columna
// Coloca un espacio horizontal en
caja_v2A =
// Creacion de una segunda caja vertical con
gtk_vbox_new(FALSE, 0);
// espaciamiento 4 entre
botones
gtk_container_add(GTK_CONTAINER(caja_hA), caja_v2A);
// que va en la segunda posicion
de la ventana
gtk_widget_set_usize(GTK_WIDGET (caja_v2A), SIZEVM, 440);
// vertical (segunda
columna)
spaceh =
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(caja_hA),spaceh);
// Coloca el boton en la ventana
caja_v3A =
// Creacion de una segunda caja horizontal con
gtk_vbox_new(FALSE, 10);
// espaciamiento 4 entre
botones
gtk_container_add(GTK_CONTAINER(caja_hA), caja_v3A);
// que va en la tercera
columna vertical
gtk_widget_set_usize(GTK_WIDGET (caja_v3A), SIZEVM, 350);
space_right =
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(caja_hA),space_right);
ventana
// Coloca el espacio en la
/***********************************************************/
/*********************Primera Columna***********************/
spacev =
vertical
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(caja_v1A),spacev);
label_pilaA =
gtk_label_new(NULL);
// Crea un espaciamiento
// Coloca el espacio en la columna
// Detalles de la etiqueta
129
gtk_container_add(GTK_CONTAINER(caja_v1A),label_pilaA);
columna
gtk_widget_set_usize(GTK_WIDGET (label_pilaA), SIZEVM, 20);
gtk_label_set_markup (GTK_LABEL (label_pilaA), "<b>PILA</b>");
en negrita
// Coloca la etiqueta en la
// La etiqueta dice "PILA"
scrolledwindowPA =
// Crea una ventana de
scroll para la pila
gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (caja_v1A), scrolledwindowPA, FALSE, FALSE, 0);
gtk_widget_set_usize(GTK_WIDGET (scrolledwindowPA), SIZEVM, 185);
textoA[0] =
// Coloca un editor de texto
en la ventana
gtk_text_view_new ();
// de scroll
gtk_container_add (GTK_CONTAINER (scrolledwindowPA), textoA[0]);
gtk_widget_set_usize(GTK_WIDGET (textoA[0]), SIZEVM, 140);
bufferA[0] =
texto
gtk_text_view_get_buffer (GTK_TEXT_VIEW (textoA[0]));
// Crea un buffer para el
spacev =
vertical
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(caja_v1A),spacev);
spacev =
vertical
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(caja_v1A),spacev);
// Crea un espaciamiento
// Coloca el espacio en la columna
// Crea un espaciamiento
// Coloca el espacio en la columna
label_statusA =
// Detalles del boton
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(caja_v1A),label_statusA);
// Coloca la etiqueta en la
ventana
gtk_widget_set_usize(GTK_WIDGET (label_statusA), SIZEVM, 20);
gtk_label_set_markup (GTK_LABEL (label_statusA), "<b>BANDERAS DE ESTADO</b>");
Flags =
// Crea una etiqueta
gtk_label_new("N
V
I
Z
C");
// con el texto N V I Z C en la parte superior
gtk_container_add(GTK_CONTAINER(caja_v1A),Flags);
// Lo coloca en la caja vertical
caja_h2A =
// Crea una caja horizontal
gtk_hbox_new(TRUE, 0);
// sin espaciamiento entre objetos de la caja
gtk_container_add(GTK_CONTAINER(caja_v1A),caja_h2A);
for(i=0; i<5; i++)
{
num = rand();
num = num % 2;
// Prueba para asignar valores binarios a cada
// bandera de estado
// Elige un numero al azar
// toma el residuo de dividirlo por 2 (solo
// puede ser 1 o 0)
sprintf(nvizc, "%d", num);
// Convierte entero a char*
entryA[i] = gtk_entry_new_with_max_length (1);
// Define cada espacio para cada
flag
gtk_entry_set_text (GTK_ENTRY(entryA[i]),nvizc);
// con el contenido de la cadena nvizc
130
gtk_container_add(GTK_CONTAINER(caja_h2A), entryA[i]);
la caja
gtk_widget_show_all (caja_h2A);
}
// lo coloca en la parte inferior de
// vertical
// Muestra todos los elementos
spacev =
vertical
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(caja_v1A),spacev);
// Crea un espaciamiento
// Coloca el espacio en la columna
/*********************Segunda Columna***********************/
label_pcA =
// Detalles de la etiqueta
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(caja_v2A),label_pcA);
// Coloca la etiqueta en la
segunda columna
gtk_widget_set_usize(GTK_WIDGET (label_pcA), 200, 20);
gtk_label_set_markup (GTK_LABEL (label_pcA), "<b>CONTADOR DE \n PROGRAMA</b>");
scrolledwindowPCA =
// Crea una ventan de
Scroll parel PC
gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (caja_v2A), scrolledwindowPCA, FALSE, FALSE, 0);
textoA[1] =
// Creaccion de un texto editable para el PC
gtk_text_view_new ();
gtk_container_add (GTK_CONTAINER (scrolledwindowPCA), textoA[1]);
gtk_widget_set_usize(GTK_WIDGET (textoA[1]), SIZEVM, 300);
bufferA[1] =
PC
gtk_text_view_get_buffer (GTK_TEXT_VIEW (textoA[1]));
// Crea un buffer para el
caja_h3A =
// Creacion de una caja horizontal
gtk_hbox_new(FALSE, 0);
// en la tercera columna
gtk_container_add(GTK_CONTAINER(caja_v2A), caja_h3A);
label_bits =
version
gtk_label_new("Version de");
gtk_container_add(GTK_CONTAINER(caja_h3A), label_bits);
sprintf(num_bits, "%d", bits);
// Etiquetqa que muestra la
// con la que se esta trabajando
// Convierte de int a char*
bit =
// Detalles de la etiqueta bits
gtk_label_new(num_bits);
bits: 8 o 32
gtk_container_add(GTK_CONTAINER(caja_h3A), bit);
label_bits2 =
gtk_label_new("Bits");
// muestra la cantidad de
// Completa la oracion:
131
Version de XX Bits
gtk_container_add(GTK_CONTAINER(caja_h3A), label_bits2);
columna
// que se muestra en la tercera
/*********************Tercera Columna***********************/
spacev =
vertical
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(caja_v3A),spacev);
// Crea un espaciamiento
// Coloca el espacio en la columna
label_acumA =
// Detalles de la etiqueta que dice
gtk_label_new(NULL);
gtk_widget_set_usize(GTK_WIDGET (label_acumA), 100, 20);
gtk_container_add(GTK_CONTAINER(caja_v3A),label_acumA);
gtk_label_set_markup (GTK_LABEL (label_acumA), "<b>ACUMULADOR</b>"); // "Acumulador" en
negrita
textoA[2] =
// Crea una linea de texto para mostrar el Acum.
gtk_text_view_new ();
gtk_container_add (GTK_CONTAINER (caja_v3A), textoA[2]);
gtk_widget_set_usize(GTK_WIDGET (textoA[2]), 40, 20);
bufferA[2] =
Acumulador
gtk_text_view_get_buffer (GTK_TEXT_VIEW (textoA[2]));
spacev =
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(caja_v3A),spacev);
// Crea un buffer parael
// Coloca un espacio vertical en la
// tercera columna
ven_vmA =
gtk_button_new_with_label("Ver Ventana de Memoria");
// Boton para ver la ventana de memoria
gtk_container_add(GTK_CONTAINER(caja_v3A), ven_vmA);
spacev =
vertical
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(caja_v3A),spacev);
// Crea un espaciamiento
// Coloca el espacio en la columna
label_regA =
// Detalles de la etiqueta que dice
gtk_label_new(NULL);
gtk_widget_set_usize(GTK_WIDGET (label_regA), 100, 20);
gtk_container_add(GTK_CONTAINER(caja_v3A),label_regA);
gtk_label_set_markup (GTK_LABEL (label_regA), "<b>Variables</b>"); // "Variables" en negrita
scrolledwindowregA =
// Crea una ventan de
Scroll parel PC
gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (caja_v3A), scrolledwindowregA, FALSE, FALSE, 0);
textoA[3] =
gtk_text_view_new ();
// Crea una linea de texto para mostrar el Acum.
132
gtk_container_add (GTK_CONTAINER (scrolledwindowregA), textoA[3]);
gtk_widget_set_usize(GTK_WIDGET (textoA[3]), 60, 160);
bufferA[3] =
Acumulador
gtk_text_view_get_buffer (GTK_TEXT_VIEW (textoA[3]));
// Crea un buffer parael
spacev =
vertical
gtk_label_new(NULL);
gtk_container_add(GTK_CONTAINER(caja_v3A),spacev);
// Crea un espaciamiento
// lo colocaen la tercera columna
}
/*---------------------------------------------------------------------------------------------------------*/
/***********************************Conectar Señales a
Eventos**********************************************/
/*---------------------------------------------------------------------------------------------------------*/
//
g_signal_connect ((gpointer) window, "destroy", G_CALLBACK (close_objects), NULL);
g_signal_connect ((gpointer) window, "destroy", G_CALLBACK (close_regs), (gpointer) window);
g_signal_connect ((gpointer) quit, "activate", G_CALLBACK (confirmation), NULL);
g_signal_connect ((gpointer) credits, "activate", G_CALLBACK (creditos), NULL);
g_signal_connect ((gpointer) save, "activate", G_CALLBACK (guardado), (gpointer) textoP[3]);
g_signal_connect ((gpointer) borrar_reg, "activate", G_CALLBACK (delete_clicked), (gpointer)
textoP[0]);
g_signal_connect ((gpointer) borrar_reg, "activate", G_CALLBACK (delete_clicked), (gpointer)
textoP[1]);
g_signal_connect ((gpointer) borrar_reg, "activate", G_CALLBACK (delete_clicked), (gpointer)
textoP[2]);
g_signal_connect ((gpointer) borrar_reg, "activate", G_CALLBACK (delete_clicked), (gpointer)
textoP[3]);
g_signal_connect ((gpointer) borrar_sel, "activate", G_CALLBACK (clear_clicked), (gpointer) textoP[0]);
g_signal_connect ((gpointer) borrar_sel, "activate", G_CALLBACK (clear_clicked), (gpointer) textoP[1]);
g_signal_connect ((gpointer) borrar_sel, "activate", G_CALLBACK (clear_clicked), (gpointer) textoP[2]);
g_signal_connect ((gpointer) borrar_sel, "activate", G_CALLBACK (clear_clicked), (gpointer) textoP[3]);
g_signal_connect ((gpointer) cut, "activate", G_CALLBACK (on_button_cut_clicked), (gpointer)
textoP[0]);
g_signal_connect ((gpointer) cut, "activate", G_CALLBACK (on_button_cut_clicked), (gpointer)
textoP[1]);
g_signal_connect ((gpointer) cut, "activate", G_CALLBACK (on_button_cut_clicked), (gpointer)
textoP[2]);
g_signal_connect ((gpointer) cut, "activate", G_CALLBACK (on_button_cut_clicked), (gpointer)
textoP[3]);
g_signal_connect ((gpointer) copy, "activate", G_CALLBACK (on_button_copy_clicked), (gpointer)
textoP[0]);
g_signal_connect ((gpointer) copy, "activate", G_CALLBACK (on_button_copy_clicked), (gpointer)
textoP[1]);
g_signal_connect ((gpointer) copy, "activate", G_CALLBACK (on_button_copy_clicked), (gpointer)
textoP[2]);
g_signal_connect ((gpointer) copy, "activate", G_CALLBACK (on_button_copy_clicked), (gpointer)
textoP[3]);
g_signal_connect ((gpointer) memoria, "activate", G_CALLBACK (on_button_vm_clicked), (gpointer)
user_data);
133
g_signal_connect ((gpointer) puertos, "activate", G_CALLBACK (on_button_vm_clicked), (gpointer)
user_data);
g_signal_connect ((gpointer) button_save, "clicked", G_CALLBACK (guardado), (gpointer) textoP[3]);
g_signal_connect ((gpointer) button_delete, "clicked", G_CALLBACK (delete_clicked), (gpointer)
textoP[0]);
g_signal_connect ((gpointer) button_delete, "clicked", G_CALLBACK (delete_clicked), (gpointer)
textoP[1]);
g_signal_connect ((gpointer) button_delete, "clicked", G_CALLBACK (delete_clicked), (gpointer)
textoP[2]);
g_signal_connect ((gpointer) button_delete, "clicked", G_CALLBACK (delete_clicked), (gpointer)
textoP[3]);
g_signal_connect ((gpointer) button_clear, "clicked", G_CALLBACK (clear_clicked), (gpointer)
textoP[0]);
g_signal_connect ((gpointer) button_clear, "clicked", G_CALLBACK (clear_clicked), (gpointer)
textoP[1]);
g_signal_connect ((gpointer) button_clear, "clicked", G_CALLBACK (clear_clicked), (gpointer)
textoP[2]);
g_signal_connect ((gpointer) button_clear, "clicked", G_CALLBACK (clear_clicked), (gpointer)
textoP[3]);
g_signal_connect ((gpointer) button_cut, "clicked", G_CALLBACK (on_button_cut_clicked), (gpointer)
textoP[0]);
g_signal_connect ((gpointer) button_cut, "clicked", G_CALLBACK (on_button_cut_clicked), (gpointer)
textoP[1]);
g_signal_connect ((gpointer) button_cut, "clicked", G_CALLBACK (on_button_cut_clicked), (gpointer)
textoP[2]);
g_signal_connect ((gpointer) button_cut, "clicked", G_CALLBACK (on_button_cut_clicked), (gpointer)
textoP[3]);
g_signal_connect ((gpointer) button_copy, "clicked", G_CALLBACK (on_button_copy_clicked),
(gpointer) textoP[0]);
g_signal_connect ((gpointer) button_copy, "clicked", G_CALLBACK (on_button_copy_clicked),
(gpointer) textoP[1]);
g_signal_connect ((gpointer) button_copy, "clicked", G_CALLBACK (on_button_copy_clicked),
(gpointer) textoP[2]);
g_signal_connect ((gpointer) button_copy, "clicked", G_CALLBACK (on_button_copy_clicked),
(gpointer) textoP[3]);
g_signal_connect ((gpointer) button_compile, "clicked", G_CALLBACK (on_button_compile), (gpointer)
user_data);
g_signal_connect ((gpointer) button_run, "clicked", G_CALLBACK (on_button_run), NULL);
g_signal_connect ((gpointer) button_next, "clicked", G_CALLBACK (on_button_step_clicked), NULL);
g_signal_connect ((gpointer) button_mem, "clicked", G_CALLBACK (on_button_vm_clicked), NULL);
g_signal_connect ((gpointer) ven_vm, "clicked", G_CALLBACK (on_button_vm_clicked), (gpointer)
user_data);
g_signal_connect ((gpointer) button_quit, "clicked", G_CALLBACK (confirmation), (gpointer) user_data);
g_signal_connect ((gpointer) credits, "activate",G_CALLBACK (on_button_mark_clicked),(gpointer)
textoP[3]);
if(Rproyecto_compilado)
{
g_signal_connect ((gpointer) button_next, "released", G_CALLBACK (marcar), (gpointer) text);
}
if(Rversioncpucr!=8)
{
g_signal_connect ((gpointer) borrar_reg, "activate", G_CALLBACK (delete_clicked), (gpointer)
134
textoA[0]);
g_signal_connect ((gpointer) borrar_reg, "activate", G_CALLBACK (delete_clicked), (gpointer)
textoA[1]);
g_signal_connect ((gpointer) borrar_reg, "activate", G_CALLBACK (delete_clicked), (gpointer)
textoA[2]);
g_signal_connect ((gpointer) borrar_reg, "activate", G_CALLBACK (delete_clicked), (gpointer)
textoA[3]);
g_signal_connect ((gpointer) borrar_sel, "activate", G_CALLBACK (clear_clicked), (gpointer) textoA[0]);
g_signal_connect ((gpointer) borrar_sel, "activate", G_CALLBACK (clear_clicked), (gpointer) textoA[1]);
g_signal_connect ((gpointer) borrar_sel, "activate", G_CALLBACK (clear_clicked), (gpointer) textoA[2]);
g_signal_connect ((gpointer) borrar_sel, "activate", G_CALLBACK (clear_clicked), (gpointer) textoA[3]);
g_signal_connect ((gpointer) cut, "activate", G_CALLBACK (on_button_cut_clicked), (gpointer)
textoA[0]);
g_signal_connect ((gpointer) cut, "activate", G_CALLBACK (on_button_cut_clicked), (gpointer)
textoA[1]);
g_signal_connect ((gpointer) cut, "activate", G_CALLBACK (on_button_cut_clicked), (gpointer)
textoA[2]);
g_signal_connect ((gpointer) cut, "activate", G_CALLBACK (on_button_cut_clicked), (gpointer)
textoA[3]);
g_signal_connect ((gpointer) copy, "activate", G_CALLBACK (on_button_copy_clicked), (gpointer)
textoA[0]);
g_signal_connect ((gpointer) copy, "activate", G_CALLBACK (on_button_copy_clicked), (gpointer)
textoA[1]);
g_signal_connect ((gpointer) copy, "activate", G_CALLBACK (on_button_copy_clicked), (gpointer)
textoA[2]);
g_signal_connect ((gpointer) copy, "activate", G_CALLBACK (on_button_copy_clicked), (gpointer)
textoA[3]);
g_signal_connect ((gpointer) button_delete, "clicked", G_CALLBACK (delete_clicked), (gpointer)
textoA[0]);
g_signal_connect ((gpointer) button_delete, "clicked", G_CALLBACK (delete_clicked), (gpointer)
textoA[1]);
g_signal_connect ((gpointer) button_delete, "clicked", G_CALLBACK (delete_clicked), (gpointer)
textoA[2]);
g_signal_connect ((gpointer) button_delete, "clicked", G_CALLBACK (delete_clicked), (gpointer)
textoA[3]);
g_signal_connect ((gpointer) button_clear, "clicked", G_CALLBACK (clear_clicked), (gpointer)
textoA[0]);
g_signal_connect ((gpointer) button_clear, "clicked", G_CALLBACK (clear_clicked), (gpointer)
textoA[1]);
g_signal_connect ((gpointer) button_clear, "clicked", G_CALLBACK (clear_clicked), (gpointer)
textoA[2]);
g_signal_connect ((gpointer) button_clear, "clicked", G_CALLBACK (clear_clicked), (gpointer)
textoA[3]);
g_signal_connect ((gpointer) button_cut, "clicked", G_CALLBACK (on_button_cut_clicked), (gpointer)
textoA[0]);
g_signal_connect ((gpointer) button_cut, "clicked", G_CALLBACK (on_button_cut_clicked), (gpointer)
textoA[1]);
g_signal_connect ((gpointer) button_cut, "clicked", G_CALLBACK (on_button_cut_clicked), (gpointer)
textoA[2]);
g_signal_connect ((gpointer) button_cut, "clicked", G_CALLBACK (on_button_cut_clicked), (gpointer)
textoA[3]);
g_signal_connect ((gpointer) button_copy, "clicked", G_CALLBACK (on_button_copy_clicked),
(gpointer) textoA[0]);
g_signal_connect ((gpointer) button_copy, "clicked", G_CALLBACK (on_button_copy_clicked),
(gpointer) textoA[1]);
135
g_signal_connect ((gpointer) button_copy, "clicked", G_CALLBACK (on_button_copy_clicked),
(gpointer) textoA[2]);
g_signal_connect ((gpointer) button_copy, "clicked", G_CALLBACK (on_button_copy_clicked),
(gpointer) textoA[3]);
g_signal_connect ((gpointer) ven_vmA, "clicked", G_CALLBACK (on_button_vm_clicked), (gpointer)
user_data);
g_signal_connect ((gpointer) credits, "activate",G_CALLBACK (on_button_mark_clicked),(gpointer)
textoA[3]);
/*
g_signal_connect ((gpointer) bufferP[0], "changed", G_CALLBACK (changed_values),(gpointer)
textoP[0]);
g_signal_connect ((gpointer) bufferP[1], "changed", G_CALLBACK (changed_values),(gpointer)
textoP[1]);
g_signal_connect ((gpointer) bufferP[2], "changed", G_CALLBACK (changed_values),(gpointer)
textoP[2]);
g_signal_connect ((gpointer) bufferP[3], "changed", G_CALLBACK (changed_values),(gpointer)
textoP[3]);
g_signal_connect ((gpointer) bufferA[0], "changed", G_CALLBACK (changed_values),(gpointer)
textoA[0]);
g_signal_connect ((gpointer) bufferA[1], "changed", G_CALLBACK (changed_values),(gpointer)
textoA[1]);
g_signal_connect ((gpointer) bufferA[2], "changed", G_CALLBACK (changed_values),(gpointer)
textoA[2]);
g_signal_connect ((gpointer) bufferA[3], "changed", G_CALLBACK (changed_values),(gpointer)
textoA[3]);
g_signal_connect ((gpointer) entryP[0], "activate", G_CALLBACK (changed_values),(gpointer)
entryP[0]);
g_signal_connect ((gpointer) entryP[1], "activate", G_CALLBACK (changed_values),(gpointer)
entryP[1]);
g_signal_connect ((gpointer) entryP[2], "activate", G_CALLBACK (changed_values),(gpointer)
entryP[2]);
g_signal_connect ((gpointer) entryP[3], "activate", G_CALLBACK (changed_values),(gpointer)
entryP[3]);
g_signal_connect ((gpointer) entryP[4], "activate", G_CALLBACK (changed_values),(gpointer)
entryP[4]);
g_signal_connect ((gpointer) entryA[0], "activate", G_CALLBACK (changed_values),(gpointer)
entryA[0]);
g_signal_connect ((gpointer) entryA[1], "activate", G_CALLBACK (changed_values),(gpointer)
entryA[1]);
g_signal_connect ((gpointer) entryA[2], "activate", G_CALLBACK (changed_values),(gpointer)
entryA[2]);
g_signal_connect ((gpointer) entryA[3], "activate", G_CALLBACK (changed_values),(gpointer)
entryA[3]);
g_signal_connect ((gpointer) entryA[4], "activate", G_CALLBACK (changed_values),(gpointer)
entryA[4]);
*/
}
/***************--------------------------------------------------------------------------------******************/
/***************-------------------------------Copia las variables------------------------------******************/
/***************--------------------------------------------------------------------------------******************/
g_assert (GTK_IS_TEXT_VIEW (user_data));
136
buff = gtk_text_view_get_buffer (GTK_TEXT_VIEW (user_data));
gtk_text_buffer_get_start_iter(GTK_TEXT_BUFFER (buff), &start);
gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER (buff), &end);
gtk_text_buffer_get_start_iter(GTK_TEXT_BUFFER (bufferP[3]), &nstart);
gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER (bufferP[3]), &nend);
exit = 0;
// Encuentra palabra "MACRO"
gtk_text_buffer_get_start_iter (buff, &iter);
do{
foundm = gtk_text_iter_forward_search (&iter, "MACRO ", GTK_TEXT_SEARCH_VISIBLE_ONLY,
&start, NULL, NULL);
if (foundm)
{
count = 0;
gtk_text_iter_forward_search (&start, "FINMAC", GTK_TEXT_SEARCH_VISIBLE_ONLY,
NULL, &end, NULL);
d = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(buff), &start, &end, FALSE);
gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER (bufferP[3]), &nend);
count = gtk_text_buffer_get_char_count (bufferP[3]);
gtk_text_buffer_get_iter_at_offset (bufferP[3], &nend, count);
gtk_text_buffer_insert (bufferP[3], &nend, d, -1);
gtk_text_buffer_insert (bufferP[3], &nend, "\n\n", -1);
iter=end;
foundm = 0;
}
else
{
exit = 1;
}
}while(exit!=1);
exit = 0;
// Encuentra palabra "macro"
gtk_text_buffer_get_start_iter (buff, &iter);
do{
foundm = gtk_text_iter_forward_search (&iter, "macro ", GTK_TEXT_SEARCH_VISIBLE_ONLY,
&start, NULL, NULL);
if (foundm)
{
count = 0;
gtk_text_iter_forward_search (&start, "finmac", GTK_TEXT_SEARCH_VISIBLE_ONLY,
NULL, &end, NULL);
d = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(buff), &start, &end, FALSE);
gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER (bufferP[3]), &nend);
count = gtk_text_buffer_get_char_count (bufferP[3]);
gtk_text_buffer_get_iter_at_offset (bufferP[3], &nend, count);
gtk_text_buffer_insert (bufferP[3], &nend, d, -1);
gtk_text_buffer_insert (bufferP[3], &nend, "\n\n", -1);
iter=end;
foundm = 0;
}
else
{
exit = 1;
}
137
}while(exit!=1);
exit = 0;
// Encuentra caracter asterisco '*'
gtk_text_buffer_get_start_iter (buff, &iter);
do{
founda = gtk_text_iter_forward_search (&iter, "*", GTK_TEXT_SEARCH_VISIBLE_ONLY, &start,
NULL, NULL);
if (founda)
{
count = 0;
gtk_text_iter_forward_search (&start, "\n", GTK_TEXT_SEARCH_VISIBLE_ONLY, NULL,
&end, NULL);
a = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(buff), &start, &end, FALSE);
gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER (bufferP[3]), &nend);
count = gtk_text_buffer_get_char_count (bufferP [3]);
gtk_text_buffer_get_iter_at_offset (bufferP[3], &nend, count);
gtk_text_buffer_insert (bufferP[3], &nend, a, -1);
iter=end;
founda = 0;
}
else
{
exit = 1;
gtk_text_buffer_insert (bufferP[3], &nend, "\n", -1);
}
}while(exit!=1);
exit = 0;
// Encuentra palabra "WRD"
gtk_text_buffer_get_start_iter (buff, &iter);
do{
foundw = gtk_text_iter_forward_search (&iter, " WRD", GTK_TEXT_SEARCH_VISIBLE_ONLY,
&start, NULL, NULL);
if (foundw)
{
count = 0;
gtk_text_iter_forward_search (&start, "\n", GTK_TEXT_SEARCH_VISIBLE_ONLY, NULL,
&end, NULL);
b = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(buff), &start, &end, FALSE);
gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER (bufferP[3]), &nend);
count = gtk_text_buffer_get_char_count (bufferP [3]);
gtk_text_buffer_get_iter_at_offset (bufferP[3], &nend, count);
gtk_text_buffer_insert (bufferP[3], &nend, b, -1);
iter=end;
foundw = 0;
}
else
{
foundw = gtk_text_iter_forward_search (&iter, "\nWRD",
GTK_TEXT_SEARCH_VISIBLE_ONLY, &start, &end, NULL);
if (foundw)
{
138
count = 0;
gtk_text_iter_forward_search (&end, "\n", GTK_TEXT_SEARCH_VISIBLE_ONLY,
NULL, &end, NULL);
b = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(buff), &start, &end, FALSE);
gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER (bufferP[3]), &nend);
count = gtk_text_buffer_get_char_count (bufferP [3]);
gtk_text_buffer_get_iter_at_offset (bufferP[3], &nend, count-1);
gtk_text_buffer_insert (bufferP[3], &nend, b, -1);
iter=end;
foundw = 0;
}
else
{
exit = 1;
}
}
}while(exit!=1);
exit = 0;
// Encuentra palabra "wrd"
gtk_text_buffer_get_start_iter (buff, &iter);
do{
foundw = gtk_text_iter_forward_search (&iter, " wrd", GTK_TEXT_SEARCH_VISIBLE_ONLY,
&start, NULL, NULL);
if (foundw)
{
count = 0;
gtk_text_iter_forward_search (&start, "\n", GTK_TEXT_SEARCH_VISIBLE_ONLY, NULL,
&end, NULL);
b = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(buff), &start, &end, FALSE);
gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER (bufferP[3]), &nend);
count = gtk_text_buffer_get_char_count (bufferP [3]);
gtk_text_buffer_get_iter_at_offset (bufferP[3], &nend, count);
gtk_text_buffer_insert (bufferP[3], &nend, b, -1);
iter=end;
foundw = 0;
}
else
{
foundw = gtk_text_iter_forward_search (&iter, "\nwrd",
GTK_TEXT_SEARCH_VISIBLE_ONLY, &start, &end, NULL);
if (foundw)
{
count = 0;
gtk_text_iter_forward_search (&end, "\n", GTK_TEXT_SEARCH_VISIBLE_ONLY,
NULL, &end, NULL);
b = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(buff), &start, &end, FALSE);
gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER (bufferP[3]), &nend);
count = gtk_text_buffer_get_char_count (bufferP [3]);
gtk_text_buffer_get_iter_at_offset (bufferP[3], &nend, count-1);
gtk_text_buffer_insert (bufferP[3], &nend, b, -1);
iter=end;
foundw = 0;
}
else
139
{
exit = 1;
}
}
}while(exit!=1);
exit = 0;
// Encuentra palabra "DBWRD"
gtk_text_buffer_get_start_iter (buff, &iter);
do{
foundb = gtk_text_iter_forward_search (&iter, "DBWRD", GTK_TEXT_SEARCH_VISIBLE_ONLY,
&start, NULL, NULL);
if (foundb)
{
count = 0;
gtk_text_iter_forward_search (&start, "\n", GTK_TEXT_SEARCH_VISIBLE_ONLY, NULL,
&end, NULL);
cc = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(buff), &start, &end, FALSE);
gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER (bufferP[3]), &nend);
count = gtk_text_buffer_get_char_count (bufferP [3]);
gtk_text_buffer_get_iter_at_offset (bufferP[3], &nend, count);
gtk_text_buffer_insert (bufferP[3], &nend, cc, -1);
iter=end;
foundb = 0;
}
else
{
exit = 1;
}
}while(exit!=1);
exit = 0;
// Encuentra palabra "dbwrd"
gtk_text_buffer_get_start_iter (buff, &iter);
do{
foundb = gtk_text_iter_forward_search (&iter, "dbwrd", GTK_TEXT_SEARCH_VISIBLE_ONLY,
&start, NULL, NULL);
if (foundb)
{
count = 0;
gtk_text_iter_forward_search (&start, "\n", GTK_TEXT_SEARCH_VISIBLE_ONLY, NULL,
&end, NULL);
cc = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(buff), &start, &end, FALSE);
gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER (bufferP[3]), &nend);
count = gtk_text_buffer_get_char_count (bufferP [3]);
gtk_text_buffer_get_iter_at_offset (bufferP[3], &nend, count);
gtk_text_buffer_insert (bufferP[3], &nend, cc, -1);
iter=end;
foundb = 0;
}
else
{
exit = 1;
}
}while(exit!=1);
140
create_tags(bufferP[3]);
on_button_mark_clicked (NULL, textoP[3]);
gtk_text_buffer_get_start_iter(GTK_TEXT_BUFFER (bufferP[3]), &start);
gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER (bufferP[3]), &end);
cpyvar = gtk_text_buffer_get_text (bufferP[3], &start, &end, TRUE);
if(Rversioncpucr!=8)
{
gtk_text_buffer_set_text (bufferA[3], cpyvar, -1);
create_tags(bufferA[3]);
on_button_mark_clicked (NULL, textoA[3]);
}
/***************------------------------Ver Resultados y Objetos----------------------------******************/
gtk_text_buffer_set_text (bufferP[0], ppP, -1); // Registros Principales
gtk_text_buffer_set_text (bufferP[1], cpP, -1);
gtk_text_buffer_set_text (bufferP[2], aaP, -1);
gtk_entry_set_text (GTK_ENTRY(entryP[0]),nnp);
gtk_entry_set_text (GTK_ENTRY(entryP[1]),vvp);
gtk_entry_set_text (GTK_ENTRY(entryP[2]),iip);
gtk_entry_set_text (GTK_ENTRY(entryP[3]),zzp);
gtk_entry_set_text (GTK_ENTRY(entryP[4]),ccp);
if(Rversioncpucr!=8)
{
gtk_text_buffer_set_text (bufferA[0], ppA, -1);
gtk_text_buffer_set_text (bufferA[1], cpA, -1);
gtk_text_buffer_set_text (bufferA[2], aaA, -1);
gtk_entry_set_text (GTK_ENTRY(entryA[0]),nna);
gtk_entry_set_text (GTK_ENTRY(entryA[1]),vva);
gtk_entry_set_text (GTK_ENTRY(entryA[2]),iia);
gtk_entry_set_text (GTK_ENTRY(entryA[3]),zza);
gtk_entry_set_text (GTK_ENTRY(entryA[4]),cca);
}
gtk_widget_show_all (window);
// Muestra todos los elementos de la vewntana de Registros
}
/*---------------------------------------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------------------------------------*/
/********************************************** METODOS
**********************************************/
/*---------------------------------------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------*/
/********************************Ventana de memoria***********************************/
141
/*-----------------------------------------------------------------------------------*/
/*************/
void on_button_vm_clicked (GtkButton * button, gpointer user_data)
{
GtkWidget *window, *scrolled;
GtkWidget *cajah, *caja, *cajah2, *cajah3, *cajah4, *cajav, *cajav2, *cajav3, *handletitle, *handlelabel;
GtkWidget *label, *titulo, *l_in, *l_out;
GtkWidget *button_add, *button_remove, *button_clear, *button_compile, *button_step, *button_run;
GtkWidget *button_position, *button_stop, *stop_position, *c_h; // Boton para seleccionar la posicion donde
detenerse
GtkTextIter start, end;
vm_created = 1;
vm_closed = 1;
linea = 0;
window =
// Ventana principal de la ventana de
memoria
gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Ventana de Memoria");
gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER);
gtk_widget_set_usize(GTK_WIDGET (window), 480, 520);
cajah =
gtk_hbox_new(TRUE, 10);
gtk_container_add(GTK_CONTAINER(window), cajah);
gtk_container_set_border_width (GTK_CONTAINER(cajah), 10);
caja =
gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(cajah), caja);
handletitle =
gtk_handle_box_new ();
gtk_box_pack_start (GTK_BOX (caja), handletitle, FALSE, FALSE, 0);
gtk_widget_set_usize(GTK_WIDGET (handletitle), 200, 36);
titulo =
gtk_label_new("Posicion
Valor
");
gtk_container_add (GTK_CONTAINER (handletitle), titulo);
scrolled =
// Ventana de memoria
gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (caja), scrolled, TRUE, TRUE, 0);
gtk_container_resize_children (GTK_CONTAINER(scrolled));
text =
gtk_text_view_new ();
// Texto de la ventana de memoria
gtk_container_add (GTK_CONTAINER (scrolled), text);
gtk_widget_set_usize(GTK_WIDGET (text), 225, 465);
cajav =
gtk_vbox_new(FALSE, 20);
gtk_container_add(GTK_CONTAINER(cajah), cajav);
142
handlelabel =
gtk_handle_box_new ();
gtk_box_pack_start (GTK_BOX (cajav), handlelabel, FALSE, FALSE, 0);
gtk_widget_set_usize(GTK_WIDGET (handlelabel), 200, 36);
label =
gtk_label_new("Visualizar Cambios\nPosicion
Valor");
gtk_container_add (GTK_CONTAINER (handlelabel), label);
constantes =
gtk_text_view_new ();
// Texto y buffer para los warnings
gtk_container_add (GTK_CONTAINER (cajav), constantes);
gtk_widget_set_usize(GTK_WIDGET (constantes), 225, 170);
cajah2 =
gtk_hbox_new(TRUE, 5);
gtk_container_add(GTK_CONTAINER(cajav), cajah2);
button_add =
gtk_button_new_with_label("Agregar");
// Boton para ver la ventana de memoria
gtk_container_add(GTK_CONTAINER(cajah2), button_add);
button_remove =
gtk_button_new_with_label("Quitar");
// Boton para ver la ventana de memoria
gtk_container_add(GTK_CONTAINER(cajah2), button_remove);
button_clear =
gtk_button_new_with_label("Limpiar");
// Boton para ver la ventana de memoria
gtk_container_add(GTK_CONTAINER(cajah2), button_clear);
cajah4 =
gtk_hbox_new(TRUE, 5);
gtk_container_add(GTK_CONTAINER(cajav), cajah4);
button_compile =
gtk_button_new_with_label("Compilar");
// Boton para Compilar desde la ventana de
memoria
gtk_container_add(GTK_CONTAINER(cajah4), button_compile);
button_run =
gtk_button_new_with_label("Ejecutar");
// Boton para Ejecutar todo desde la ventana de memoria
gtk_container_add(GTK_CONTAINER(cajah4), button_run);
button_step =
gtk_button_new_with_label("Siguiente");
// Boton para Ejecutar paso a paso ventana de
memoria
gtk_container_add(GTK_CONTAINER(cajah4), button_step);
c_h =
gtk_hbox_new(TRUE, 0);
gtk_container_add(GTK_CONTAINER(cajav), c_h);
stop_position =
gtk_toggle_button_new_with_label ("Parar en");;
gtk_container_add(GTK_CONTAINER(c_h), stop_position);
143
button_position =
gtk_spin_button_new_with_range (0, 65535, 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON(button_position), 65535);
gtk_container_add(GTK_CONTAINER(c_h), button_position);
button_stop =
gtk_button_new_with_label ("Detener"); // Boton para detener Ejecucion desde la ventana de memoria
gtk_container_add(GTK_CONTAINER(c_h), button_stop);
cajah3 =
gtk_hbox_new(TRUE, 10);
gtk_container_add(GTK_CONTAINER(cajav), cajah3);
cajav2 =
gtk_vbox_new(TRUE, 0);
gtk_container_add(GTK_CONTAINER(cajah3), cajav2);
puertos[0] =
gtk_entry_new_with_max_length (8);
// Puerto de entrada
gtk_container_add(GTK_CONTAINER(cajav2), puertos[0]);
l_in =
gtk_label_new("Puerto de\nEntrada");
gtk_container_add (GTK_CONTAINER (cajav2), l_in);
cajav3 =
gtk_vbox_new(TRUE, 10);
gtk_container_add(GTK_CONTAINER(cajah3), cajav3);
puertos[1] = gtk_entry_new_with_max_length (8);
// Puerto de salida
gtk_container_add(GTK_CONTAINER(cajav3), puertos[1]);
l_out =
gtk_label_new("Puerto de\nSalida");
gtk_container_add (GTK_CONTAINER (cajav3), l_out);
buffervm = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text)); // contenido de la ventana de memoria
bufferconst = gtk_text_view_get_buffer (GTK_TEXT_VIEW (constantes));
gtk_text_buffer_set_text (buffervm, ventana_de_memoria1, -1);
gtk_text_buffer_get_end_iter (buffervm, &end);
gtk_text_buffer_insert (buffervm, &end, ventana_de_memoria2, -1);
gtk_text_buffer_get_end_iter (buffervm, &end);
gtk_text_buffer_insert (buffervm, &end, ventana_de_memoria3, -1);
gtk_text_buffer_get_end_iter (buffervm, &end);
gtk_text_buffer_insert (buffervm, &end, ventana_de_memoria4, -1);
gtk_entry_set_text (GTK_ENTRY(puertos[0]), puerto_in);// Le asigna el valor del puerto de entrada
gtk_entry_set_text (GTK_ENTRY(puertos[1]), puerto_out);// Le asigna el valor del puerto de salida
create_tags(buffervm);
create_tags(bufferconst);
gtk_text_buffer_get_start_iter (buffervm, &start);
gtk_text_buffer_get_end_iter (buffervm, &end);
gtk_text_buffer_apply_tag_by_name (buffervm, "centrar", &start, &end);
144
g_signal_connect ((gpointer) button_add, "clicked", G_CALLBACK (add_const), (gpointer) text);
g_signal_connect ((gpointer) button_remove, "clicked", G_CALLBACK (remove_const), (gpointer)
constantes);
g_signal_connect ((gpointer) button_clear, "clicked", G_CALLBACK (clear_const), (gpointer) constantes);
g_signal_connect ((gpointer) button_compile, "clicked", G_CALLBACK (on_button_compile), (gpointer)
user_data);
g_signal_connect ((gpointer) button_run, "clicked", G_CALLBACK (on_button_run), NULL);
g_signal_connect ((gpointer) button_step, "clicked", G_CALLBACK (on_button_step_clicked), (gpointer)
text);
g_signal_connect ((gpointer) button_step, "released", G_CALLBACK (marcar), (gpointer) text);
g_signal_connect ((gpointer) button_stop, "clicked", G_CALLBACK (on_button_stop),
(gpointer)button_stop);
g_signal_connect ((gpointer) stop_position, "clicked", G_CALLBACK (on_button_stop_position),
(gpointer)stop_position);
g_signal_connect ((gpointer) button_position,"value_changed",G_CALLBACK
(on_button_stop_point),(gpointer)button_position);
g_signal_connect ((gpointer)
button_position,"value_changed",G_CALLBACK(on_button_stop_position),(gpointer)stop_position);
g_signal_connect ((gpointer) window, "destroy", G_CALLBACK (close_win), (gpointer) window);
gtk_widget_show_all(window);
}
/*-----------------------------------------------------------------------------------*/
/*********************************Marcar Posiciones***********************************/
/*-----------------------------------------------------------------------------------*/
void marcar (GtkTextIter prueba, gpointer user_data)
{
GtkTextIter start, end;
int count;
if(vm_created)
{
if(Rproyecto_compilado)
{
gtk_text_buffer_get_start_iter (buffervm, &start);
gtk_text_buffer_get_end_iter (buffervm, &end);
gtk_text_buffer_remove_tag_by_name (buffervm, "under", &start, &end);
gtk_text_buffer_remove_tag_by_name (buffervm, "bold", &start, &end);
gtk_text_buffer_remove_tag_by_name (buffervm, "instruccion", &start, &end);
gtk_text_buffer_get_iter_at_line (buffervm, &start, Pos_VM);
gtk_text_buffer_get_iter_at_line (buffervm, &end, Pos_VM+1);
count = gtk_text_buffer_get_line_count (buffervm);
if(count==Pos_VM+1){
gtk_text_buffer_get_end_iter (buffervm, &end);}
gtk_text_buffer_place_cursor (buffervm, &start);
gtk_text_buffer_apply_tag_by_name (buffervm, "under", &start, &end);
gtk_text_buffer_apply_tag_by_name (buffervm, "bold", &start, &end);
gtk_text_buffer_apply_tag_by_name (buffervm, "instruccion", &start, &end);
gtk_text_buffer_apply_tag_by_name (buffervm, "centrar", &start, &end);
}
145
}
}
/*-----------------------------------------------------------------------------------*/
/********************************Agregar Posiciones***********************************/
/*-----------------------------------------------------------------------------------*/
void add_const (GtkButton * button, gpointer user_data)
{
GtkWidget *dialog;
GtkTextIter start, iter, iter2, end, final;
GtkTextBuffer *buffer;
gchar *textin;
int posicion_iter, count;
g_assert (GTK_IS_TEXT_VIEW (user_data));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (user_data));
gtk_text_buffer_get_start_iter (buffer, &iter2);
gtk_text_buffer_get_selection_bounds (buffer, &iter2, NULL);
posicion_iter = gtk_text_iter_get_line (&iter2);
marcas_de_posicion[linea] = posicion_iter;
linea = linea + 1;
gtk_text_buffer_get_start_iter (buffer, &start);
gtk_text_buffer_get_end_iter (buffer, &end);
gtk_text_buffer_remove_tag_by_name (buffer, "under", &start, &end);
gtk_text_buffer_remove_tag_by_name (buffer, "bold", &start, &end);
gtk_text_buffer_remove_tag_by_name (buffer, "coment", &start, &end);
gtk_text_buffer_get_selection_bounds (buffer, &iter, NULL);
posicion_iter = gtk_text_iter_get_line (&iter);
gtk_text_buffer_get_iter_at_line (buffer, &start, posicion_iter);
gtk_text_buffer_get_iter_at_line (buffer, &end, posicion_iter+1);
count = gtk_text_buffer_get_line_count (buffer);
if(count==posicion_iter+1){
gtk_text_buffer_get_end_iter (buffer, &end);}
textin = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(buffer), &start, &end, TRUE);
gtk_text_buffer_get_end_iter (bufferconst, &final);
gtk_text_buffer_insert (bufferconst, &final, textin, -1);
if(count==posicion_iter+1){
gtk_text_buffer_insert (bufferconst, &final, "\n", -1);}
gtk_text_buffer_get_start_iter (bufferconst, &start);
gtk_text_buffer_get_end_iter (bufferconst, &end);
gtk_text_buffer_apply_tag_by_name (bufferconst, "centrar", &start, &end);
if(linea >= MAX_VALUE)
{
dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL,
//Lo que imprime la ventana de
146
informacion
GTK_MESSAGE_INFO,
GTK_BUTTONS_CLOSE,
"\n\nSolo puede agregar 10 valores!! si agrega mas\nestos no
se agregaran a esta ventana");
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER); // Posicion de la
ventana de dialogo
gtk_dialog_run (GTK_DIALOG (dialog));
// Corre el dialogo
gtk_widget_destroy (dialog);
linea = MAX_VALUE;
}
}
/*-----------------------------------------------------------------------------------*/
/********************************Remover Posiciones***********************************/
/*-----------------------------------------------------------------------------------*/
void remove_const (GtkButton * button, gpointer user_data)
{
GtkTextIter start, iter, end;
GtkTextBuffer *buffer;
int i, posicion_iter, count;
g_assert (GTK_IS_TEXT_VIEW (user_data));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (user_data));
gtk_text_buffer_get_start_iter (buffer, &start);
gtk_text_buffer_get_end_iter (buffer, &end);
gtk_text_buffer_get_selection_bounds (buffer, &iter, NULL);
posicion_iter = gtk_text_iter_get_line (&iter);
gtk_text_buffer_get_start_iter (buffer, &iter);
gtk_text_buffer_get_selection_bounds (buffer, &iter, NULL);
posicion_iter = gtk_text_iter_get_line (&iter);
/**/
for(i=posicion_iter; i<linea; i++)
{
marcas_de_posicion[i] = marcas_de_posicion[i+1];
}
marcas_de_posicion[linea] = 0;
linea = linea - 1;
posicion_iter = gtk_text_iter_get_line (&iter);
/**/
gtk_text_buffer_get_iter_at_line (buffer, &start, posicion_iter);
gtk_text_buffer_get_iter_at_line (buffer, &end, posicion_iter+1);
count = gtk_text_buffer_get_line_count (buffer);
if(count==posicion_iter+1){
gtk_text_buffer_get_end_iter (buffer, &end);}
gtk_text_buffer_select_range (buffer, &start, &end );
gtk_text_buffer_delete (buffer, &start, &end);
}
147
/*-----------------------------------------------------------------------------------*/
/***************************Limpiar ventana de constantes*****************************/
/*-----------------------------------------------------------------------------------*/
void clear_const (GtkButton * button, gpointer user_data)
{
GtkTextBuffer *buffer;
GtkTextIter start, end;
linea = 0;
g_assert (GTK_IS_TEXT_VIEW (user_data));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (user_data));
gtk_text_buffer_get_start_iter (buffer, &start);
gtk_text_buffer_get_end_iter (buffer, &end);
gtk_text_buffer_get_bounds (buffer, &start, &end);
gtk_text_buffer_delete (buffer, &start, &end);
}
void changed_values(GtkButton * button, gpointer user_data)
{
GtkTextIter start1, end1;
GtkTextIter start2, end2;
GtkTextIter start3, end3;
GtkTextIter start4, end4;
GtkTextIter start5, end5;
GtkTextIter start6, end6;
const gchar* textin;
gtk_text_buffer_get_start_iter (bufferP[0], &start1);
gtk_text_buffer_get_end_iter (bufferP[0], &end1);
RprincPila = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(bufferP[0]), &start1, &end1, TRUE);
gtk_text_buffer_get_start_iter (bufferP[1], &start2);
gtk_text_buffer_get_end_iter (bufferP[1], &end2);
RprincPC = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(bufferP[1]), &start2, &end2, TRUE);
gtk_text_buffer_get_start_iter (bufferP[2], &start3);
gtk_text_buffer_get_end_iter (bufferP[2], &end3);
RprincAcum = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(bufferP[2]), &start3, &end3,
TRUE);
if(Rversioncpucr!=8)
{
gtk_text_buffer_get_start_iter (bufferA[0], &start4);
gtk_text_buffer_get_end_iter (bufferA[0], &end4);
RAuxPila = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(bufferA[0]), &start4, &end4, TRUE);
gtk_text_buffer_get_start_iter (bufferA[1], &start5);
gtk_text_buffer_get_end_iter (bufferA[1], &end5);
RAuxPC = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(bufferA[1]), &start5, &end5, TRUE);
gtk_text_buffer_get_start_iter (bufferA[2], &start6);
gtk_text_buffer_get_end_iter (bufferA[2], &end6);
RAuxAcum = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(bufferA[2]), &start6, &end6,
TRUE);
148
}
textin = gtk_entry_get_text (GTK_ENTRY(entryP[0]));
RprincN = (char*)textin;
textin = gtk_entry_get_text (GTK_ENTRY(entryP[1]));
RprincV = (char*)textin;
textin = gtk_entry_get_text (GTK_ENTRY(entryP[2]));
RprincI = (char*)textin;
textin = gtk_entry_get_text (GTK_ENTRY(entryP[3]));
RprincZ = (char*)textin;
textin = gtk_entry_get_text (GTK_ENTRY(entryP[4]));
RprincC = (char*)textin;
if(Rversioncpucr!=8)
{
textin = gtk_entry_get_text (GTK_ENTRY(entryA[0]));
RAuxN = (char*)textin;
textin = gtk_entry_get_text (GTK_ENTRY(entryA[1]));
RAuxV = (char*)textin;
textin = gtk_entry_get_text (GTK_ENTRY(entryA[2]));
RAuxI = (char*)textin;
textin = gtk_entry_get_text (GTK_ENTRY(entryA[3]));
RAuxZ = (char*)textin;
textin = gtk_entry_get_text (GTK_ENTRY(entryA[4]));
RAuxC = (char*)textin;
}
}
void changed_vm(GtkButton * button, gpointer user_data)
{
GtkTextIter start, end;
if( gtk_text_buffer_get_modified(buffervm) )
{
gtk_text_buffer_get_start_iter (buffervm, &start);
gtk_text_buffer_get_iter_at_line (buffervm, &end, 16384);
ventana_de_memoria1 = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(buffervm), &start, &end,
TRUE);
gtk_text_buffer_get_iter_at_line (buffervm, &start, 16384);
gtk_text_buffer_get_iter_at_line (buffervm, &end, 2*16384);
ventana_de_memoria2 = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(buffervm), &start, &end,
TRUE);
gtk_text_buffer_get_iter_at_line (buffervm, &start, 2*16384);
gtk_text_buffer_get_iter_at_line (buffervm, &end, 3*16384);
ventana_de_memoria3 = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(buffervm), &start, &end,
TRUE);
gtk_text_buffer_get_iter_at_line (buffervm, &start, 3*16384);
gtk_text_buffer_get_end_iter (buffervm, &end);
ventana_de_memoria4 = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(buffervm), &start, &end,
TRUE);
}
}
/*-----------------------------------------------------------------------------------*/
149
/***********************************Boton Compilar************************************/
/*-----------------------------------------------------------------------------------*/
void on_button_compile (GtkButton * button, gpointer user_data)
{
GtkWidget *dialog;
GtkTextBuffer *buffer;
GtkTextIter start;
GtkTextIter end;
char *codigo;
// Variable que toma el codigo
const char *caso1="8", *caso2="32", *vb;
Detener=0;
primer_step=0;
on_button_save_clicked(NULL, user_data);
g_assert (GTK_IS_TEXT_VIEW (user_data));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (user_data));
// toma el codigo
escrito en el
gtk_text_buffer_get_start_iter(GTK_TEXT_BUFFER (buffer), &start);
// editor de texto
como un
gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER (buffer), &end);
// char*
especificamente en la
codigo = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(buffer), &start, &end, FALSE); // variable
codigo
if(vm_created)
{
if(vm_closed)
{
gtk_text_buffer_get_start_iter(GTK_TEXT_BUFFER (buffervm), &start);
// editor de
texto como un
gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER (buffervm), &end);
// char*
especificamente en la
ventana_de_memoria1 = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(buffervm), &start,
&end, FALSE);//Vent. de mem.
g_signal_connect ((gpointer) entryP[0], "activate", G_CALLBACK (changed_values),(gpointer)
entryP[0]);
g_signal_connect ((gpointer) buffervm, "changed", G_CALLBACK (changed_vm),(gpointer) text);
}
}
if(Rversioncpucr==8){
vb=caso1;}
else{
vb=caso2;}
/*----------------------------------------------------------------------------------------------*/
Interfaz Interfaz1;
Interfaz1.setCMPL(Rdireccion, vb, codigo, Pos_VM, ventana_de_memoria1, puerto_in, puerto_out,
RprincPila, RprincPC,
RprincAcum, RAuxPila, RAuxPC, RAuxAcum, RprincN, RprincV, RprincI, RprincZ, RprincC, RAuxN,
RAuxV, RAuxI, RAuxZ, RAuxC);
// Aqui le envio el codigo escrito en el editor al objeto
Radvertencias = Interfaz1.getADV();
// Obtiene Advertencias
150
Rproyecto_compilado = Interfaz1.getCompilado();
exitosamente
// Obtiene si el proyecto fue compilado
if(!Rproyecto_compilado)
{
dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, //Lo que imprime la
ventana de informacion
GTK_MESSAGE_INFO,
GTK_BUTTONS_CLOSE,
"\n\nProyecto compilado Exitosamente!!");
}
else
{
dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, //Lo que imprime la
ventana de informacion
GTK_MESSAGE_INFO,
GTK_BUTTONS_CLOSE,
"\n\nEl proyecto no fue compilado exitosamente!!");
}
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER); // Posicion de la
ventana de dialogo
gtk_dialog_run (GTK_DIALOG (dialog));
// Corre el dialogo
gtk_widget_destroy (dialog);
}
/*-----------------------------------------------------------------------------------*/
/********************************Ejecutar paso a paso*********************************/
/*-----------------------------------------------------------------------------------*/
void on_button_step_clicked (GtkButton * button, gpointer user_data)
{
/*--------------------------------------------Variables-----------------------------------------*/
GtkWidget *dialog;
GtkTextIter start, start2, inicio, final;
GtkTextIter end, end2, posicionador;
GtkTextIter startvm, endvm;
gchar *old_new;
char *vb, *posicion_que_cambia; // Variable que toma el codigo
const char *caso1="8", *caso2="32";
int i, count;
if(Rversioncpucr==8){
vb=(char*)caso1;}
else{
vb=(char*)caso2;}
g_signal_connect ((gpointer) entryP[0], "activate", G_CALLBACK (changed_values),NULL);
/*------------------------------------------conexion con el metodo------------------------------*/
Interfaz2.setStep(Rdireccion, vb, Detener, Pos_VM);// Aqui le envio el codigo escrito en el editor al
151
objeto
Radvertencias = Interfaz2.getADV();
// Obtiene Advertencias
puerto_in = Interfaz2.getPort_IN();
// Obtiene puerto de entrada
puerto_out = Interfaz2.getPort_OUT();
// Obtiene puerto de salida
Pos_VM = Interfaz2.getPosicion_VM();
posicion_que_cambia=string_to_char(Interfaz2.getVm1());//Obtiene el valor de la Posicion y su
contenido que cambia
//
|
RprincPila = Interfaz2.getPP();
// Obtiene Pila principal
|
RprincPC = Interfaz2.getPCP();
// Obtiene PC principal
|
RprincAcum = Interfaz2.getAP();
// Obtiene Acumulador principal
V
RAuxPila = Interfaz2.getPA();
// Obtiene Pila Auxiliar
.
RAuxPC = Interfaz2.getPCA();
// Obtiene PC Auxiliar
.
RAuxAcum = Interfaz2.getAA();
// Obtiene Acumulador Auxiliar
.
RprincN = Interfaz2.getNP();
RprincV = Interfaz2.getVP();
RprincI = Interfaz2.getIP();
RprincZ = Interfaz2.getZP();
RprincC = Interfaz2.getCP();
RAuxN = Interfaz2.getNA();
RAuxV = Interfaz2.getVA();
RAuxI = Interfaz2.getIA();
RAuxZ = Interfaz2.getZA();
RAuxC = Interfaz2.getCA();
// Obtiene N principal
// Obtiene V principal
// Obtiene I principal
// Obtiene Z principal
// Obtiene Z principal
// Obtiene N Auxiliar
// Obtiene V Auxiliar
// Obtiene I Auxiliar
// Obtiene Z Auxiliar
// Obtiene C Auxiliar
if(!Rproyecto_compilado)
{
if(!primer_step)
{
gtk_text_buffer_set_text (bufferP[1], RprincPC, -1);
if(Rversioncpucr!=8)
{
gtk_text_buffer_set_text (bufferA[1], RAuxPC, -1);
}
primer_step = 1;
}
else
{
gtk_text_buffer_get_start_iter (bufferP[1], &start);
gtk_text_buffer_insert (bufferP[1], &start, "\n", -1);
gtk_text_buffer_get_start_iter (bufferP[1], &start);
gtk_text_buffer_insert (bufferP[1], &start, RprincPC, -1);
if(Rversioncpucr!=8)
{
gtk_text_buffer_get_start_iter (bufferA[1], &start);
gtk_text_buffer_insert (bufferA[1], &start, "\n", -1);
152
gtk_text_buffer_get_start_iter (bufferA[1], &start);
gtk_text_buffer_insert (bufferA[1], &start, RAuxPC, -1);
}
}
gtk_text_buffer_set_text (bufferP[0], RprincPila, -1); // Registros Principales
gtk_text_buffer_set_text (bufferP[2], RprincAcum, -1);
gtk_entry_set_text (GTK_ENTRY(entryP[0]),RprincN);
gtk_entry_set_text (GTK_ENTRY(entryP[1]),RprincV);
gtk_entry_set_text (GTK_ENTRY(entryP[2]),RprincI);
gtk_entry_set_text (GTK_ENTRY(entryP[3]),RprincZ);
gtk_entry_set_text (GTK_ENTRY(entryP[4]),RprincC);
if(Rversioncpucr!=8)
{
gtk_text_buffer_set_text (bufferA[0], RAuxPila, -1);
gtk_text_buffer_set_text (bufferA[2], RAuxAcum, -1);
gtk_entry_set_text (GTK_ENTRY(entryA[0]),RAuxN);
gtk_entry_set_text (GTK_ENTRY(entryA[1]),RAuxV);
gtk_entry_set_text (GTK_ENTRY(entryA[2]),RAuxI);
gtk_entry_set_text (GTK_ENTRY(entryA[3]),RAuxZ);
gtk_entry_set_text (GTK_ENTRY(entryA[4]),RAuxC);
}
/*--------------------------Remover Tag y sustituir valor de la V.M. que cambia-----------------------*/
if(vm_created)
{
if(vm_closed)
{
gtk_entry_set_text (GTK_ENTRY(puertos[0]),puerto_in);
gtk_entry_set_text (GTK_ENTRY(puertos[1]),puerto_out);
}
gtk_text_buffer_get_start_iter (buffervm, &start);
gtk_text_buffer_get_end_iter (buffervm, &end);
gtk_text_buffer_get_iter_at_line (buffervm, &posicionador, Pos_VM); // Ubicar el cursor en dondu hubo el
cambio
gtk_text_buffer_place_cursor (buffervm, &posicionador);
gtk_text_view_scroll_to_iter (GTK_TEXT_VIEW(text), &posicionador,NULL, NULL, NULL, NULL);
gtk_text_buffer_remove_tag_by_name (buffervm, "under", &start, &end);// Remover negrita, subrayado y
color azul
gtk_text_buffer_remove_tag_by_name (buffervm, "bold", &start, &end);
gtk_text_buffer_remove_tag_by_name (buffervm, "instruccion", &start, &end);
gtk_text_buffer_get_iter_at_line (buffervm, &startvm, Pos_VM); // Ubica al iter al principio y al final de la
.
gtk_text_buffer_get_iter_at_line (buffervm, &endvm, Pos_VM+1); // posicion de la ventana de memoria
que cambio
.
//
.
153
gtk_text_buffer_delete (buffervm, &startvm, &endvm);
// Borra el antiguo valor de la posicion
.
gtk_text_buffer_get_iter_at_line (buffervm, &startvm, Pos_VM); // Ubica al iter al principio y al final de la
|
gtk_text_buffer_get_iter_at_line (buffervm, &endvm, Pos_VM+1); // posicion que cambio
|
//
|
gtk_text_buffer_insert (buffervm, &startvm, posicion_que_cambia, -1); // Inserta el nuevo valor de la
posicion <---gtk_text_buffer_get_iter_at_line (buffervm, &startvm, Pos_VM); // Ubica al iter al principio y al final de la
gtk_text_buffer_get_iter_at_line (buffervm, &endvm, Pos_VM+1); // posicion que fue marcada y que
cambio
if(Pos_VM==31){
// Si esta en la U.L. ubique el iter
gtk_text_buffer_get_end_iter (buffervm, &endvm);}// al final de todo el texto
gtk_text_buffer_apply_tag_by_name (buffervm, "under", &startvm, &endvm); // Aplica negrita,
subrayado, azul y centrado
gtk_text_buffer_apply_tag_by_name (buffervm, "bold", &startvm, &endvm);
gtk_text_buffer_apply_tag_by_name (buffervm, "instruccion", &startvm, &endvm);
gtk_text_buffer_apply_tag_by_name (buffervm, "centrar", &startvm, &endvm);
/*-----------------------------Marcar la constante que cambio-----------------------------------*/
for(i=0; i<linea; i++)
{
gtk_text_buffer_get_iter_at_line (buffervm, &start, marcas_de_posicion[i]);// Ubica al iter al
principio y final de
gtk_text_buffer_get_iter_at_line (buffervm, &end, marcas_de_posicion[i]+1);// lo que se desea
copiar
count = gtk_text_buffer_get_line_count (buffervm);
// Obtiene el nuevo valor
de la posicion
if(marcas_de_posicion[i]==count){
// Si esta en la U.L. ubique
el iter
gtk_text_buffer_get_end_iter (buffervm, &end);}
// al final de todo el texto
old_new = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(buffervm), &start, &end, TRUE); //
Valor a cambiar
if(marcas_de_posicion[i]==Pos_VM)
de la Ventana de
{
alguna de las marcadas
// Pregunta si la posicion
// memoria coincide con
gtk_text_buffer_get_iter_at_line (bufferconst, &start2, i); // Ubica al iter al principio y al
final de la
gtk_text_buffer_get_iter_at_line (bufferconst, &end2, i+1); // posicion que fue marcada y
que cambio
gtk_text_buffer_delete (bufferconst, &start2, &end2);
// Borra el antiguo valor de la
posicion
gtk_text_buffer_get_iter_at_line (bufferconst, &start2, i); // Ubica al iter al principio y al
final de la
gtk_text_buffer_get_iter_at_line (bufferconst, &end2, i+1); // posicion que fue marcada y
que cambio
154
gtk_text_buffer_insert (bufferconst, &start2, old_new, -1); // Inserta el nuevo valor de la
posicion
gtk_text_buffer_get_iter_at_line (bufferconst, &start2, i); // Ubica al iter al principio y al
final de la
gtk_text_buffer_get_iter_at_line (bufferconst, &end2, i+1); // posicion que fue marcada y
que cambio
if(i==linea-1){
// Si esta en la U.L. ubique el
iter
gtk_text_buffer_get_end_iter (bufferconst, &end2);}// al final de todo el texto
gtk_text_buffer_get_start_iter (bufferconst, &inicio);
// Ubica al iter al principio y al final
de la
gtk_text_buffer_get_end_iter (bufferconst, &final);
// ventana de constantes
gtk_text_buffer_get_iter_at_line (bufferconst, &start2, i); // Ubica al iter al principio y al
final de la
gtk_text_buffer_get_iter_at_line (bufferconst, &end2, i+1); // posicion que fue marcada y
que cambio
gtk_text_buffer_place_cursor (bufferconst, &start2);
// Ubica el cursor en la posicion
que cambia
gtk_text_buffer_remove_tag_by_name (bufferconst, "under", &inicio, &final); // Quita
negrita y subrayado
gtk_text_buffer_remove_tag_by_name (bufferconst, "bold", &inicio, &final);
gtk_text_buffer_remove_tag_by_name (bufferconst, "instruccion", &inicio, &final);
gtk_text_buffer_apply_tag_by_name (bufferconst, "under", &start2, &end2); // Aplica
negrita y subrayado
gtk_text_buffer_apply_tag_by_name (bufferconst, "bold", &start2, &end2);
gtk_text_buffer_apply_tag_by_name (bufferconst, "instruccion", &start2, &end2);
gtk_text_buffer_apply_tag_by_name (bufferconst, "centrar", &start2, &end2);
} // marcas coinciden?
} // for
} // VM creada Detener=0;
} // Proyecto compilado
else
{
dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, //Lo que imprime la
ventana de informacion
GTK_MESSAGE_INFO,
GTK_BUTTONS_CLOSE,
"\n\nAntes de Ejecutar paso a paso, debe Compilar Exitosamente
el Proyecto");
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER); // Posicion de
la ventana de dialogo
gtk_dialog_run (GTK_DIALOG (dialog));
// Corre el dialogo
gtk_widget_destroy (dialog);
}
}
/*-----------------------------------------------------------------------------------*/
/**************************************Ejecutar***************************************/
155
/*-----------------------------------------------------------------------------------*/
void on_button_run (GtkButton * button, gpointer user_data)
{
int i, count;
const char *caso1="8", *caso2="32", *vb;
string mem1, mem2, mem3, mem4, mem5, mem6, mem7, mem8;
gchar* old_new;
GtkWidget *dialog;
GtkTextIter start, end;
if(Rversioncpucr==8){
vb=caso1;}
else{
vb=caso2;}
/*----------------------------------------------------------------------------------------------*/
Interfaz Interfaz1;
if(To_posicion)
{
Interfaz1.setRun(Rdireccion, vb, Pos_VM, 0, VALOR_V_M);
}
else
{
Interfaz1.setRun(Rdireccion, vb, 65535, 0, VALOR_V_M);
}
puerto_in = Interfaz1.getPort_IN();
// Obtiene puerto de entrada
puerto_out = Interfaz1.getPort_OUT();
// Obtiene puerto de salida
registro_de_instrucciones = Interfaz1.getR_I();
RprincPila = Interfaz1.getPP();
// Obtiene Pila principal
RprincPC = Interfaz1.getPCP();
// Obtiene PC principal
RprincAcum = Interfaz1.getAP();
// Obtiene Acumulador principal
RAuxPila = Interfaz1.getPA();
// Obtiene Pila Auxiliar
RAuxPC = Interfaz1.getPCA();
// Obtiene PC Auxiliar
RAuxAcum = Interfaz1.getAA();
// Obtiene Acumulador Auxiliar
RprincN = Interfaz1.getNP();
// Obtiene N principal
RprincV = Interfaz1.getVP();
// Obtiene V principal
RprincI = Interfaz1.getIP();
// Obtiene I principal
RprincZ = Interfaz1.getZP();
// Obtiene Z principal
RprincC = Interfaz1.getCP();
// Obtiene Z principal
RAuxN = Interfaz1.getNA();
// Obtiene N Auxiliar
RAuxV = Interfaz1.getVA();
// Obtiene V Auxiliar
RAuxI = Interfaz1.getIA();
// Obtiene I Auxiliar
RAuxZ = Interfaz1.getZA();
// Obtiene Z Auxiliar
RAuxC = Interfaz1.getCA();
// Obtiene C Auxiliar
/*----------------------------------------------------------------------------------------------*/
Detener=0;
primer_step=0;
if(!Rproyecto_compilado)
{
gtk_text_buffer_set_text (bufferP[0], RprincPila, -1); // Registros Principales
156
gtk_text_buffer_set_text (bufferP[1], RprincPC, -1);
gtk_text_buffer_set_text (bufferP[2], RprincAcum, -1);
gtk_text_buffer_set_text (buffer_instrucciones, registro_de_instrucciones, -1);
gtk_entry_set_text (GTK_ENTRY(entryP[0]),RprincN);
gtk_entry_set_text (GTK_ENTRY(entryP[1]),RprincV);
gtk_entry_set_text (GTK_ENTRY(entryP[2]),RprincI);
gtk_entry_set_text (GTK_ENTRY(entryP[3]),RprincZ);
gtk_entry_set_text (GTK_ENTRY(entryP[4]),RprincC);
if(Rversioncpucr!=8)
{
gtk_text_buffer_set_text (bufferA[0], RAuxPila, -1);
gtk_text_buffer_set_text (bufferA[1], RAuxPC, -1);
gtk_text_buffer_set_text (bufferA[2], RAuxAcum, -1);
gtk_entry_set_text (GTK_ENTRY(entryA[0]),RAuxN);
gtk_entry_set_text (GTK_ENTRY(entryA[1]),RAuxV);
gtk_entry_set_text (GTK_ENTRY(entryA[2]),RAuxI);
gtk_entry_set_text (GTK_ENTRY(entryA[3]),RAuxZ);
gtk_entry_set_text (GTK_ENTRY(entryA[4]),RAuxC);
}
if(vm_created)
{
if(vm_closed)
{
mem1 = Interfaz1.getVm1();
// Obtiene la Ventana de
mem2 = Interfaz1.getVm3();
// Obtiene la Ventana de
mem3 = Interfaz1.getVm5();
// Obtiene la Ventana de
mem4 = Interfaz1.getVm7();
// Obtiene la Ventana de
mem5 = Interfaz1.getVm2();
// Obtiene la Ventana de
mem6 = Interfaz1.getVm4();
// Obtiene la Ventana de
mem7 = Interfaz1.getVm6();
// Obtiene la Ventana de
mem8 = Interfaz1.getVm8();
// Obtiene la Ventana de
memoria
memoria
memoria
memoria
memoria
memoria
memoria
memoria
mem1 = mem1 + mem5;
mem2 = mem2 + mem6;
mem3 = mem3 + mem7;
mem4 = mem4 + mem8;
mem1 = mem1 + mem2 + mem3 + mem4;
ventana_de_memoria1 = string_to_char(mem1);
// Obtiene la Ventana de
memoria
gtk_entry_set_text (GTK_ENTRY(puertos[0]),puerto_in);
gtk_entry_set_text (GTK_ENTRY(puertos[1]),puerto_out);
gtk_text_buffer_set_text (buffervm, ventana_de_memoria1, -1);
157
gtk_text_buffer_get_start_iter (buffervm, &start);
gtk_text_buffer_get_end_iter (buffervm, &end);
gtk_text_buffer_apply_tag_by_name (buffervm, "centrar", &start, &end);
for(i=0; i<linea; i++)
{
gtk_text_buffer_get_iter_at_line (buffervm, &start, marcas_de_posicion[i]);
gtk_text_buffer_get_iter_at_line (buffervm, &end, marcas_de_posicion[i]+1);
count = gtk_text_buffer_get_line_count (buffervm);
if(marcas_de_posicion[i]==count){
gtk_text_buffer_get_end_iter (buffervm, &end);}
old_new = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(buffervm), &start,
&end, TRUE);
gtk_text_buffer_get_iter_at_line (bufferconst, &start, i);
gtk_text_buffer_get_iter_at_line (bufferconst, &end, i+1);
gtk_text_buffer_delete (bufferconst, &start, &end);
gtk_text_buffer_get_iter_at_line (bufferconst, &start, i);
gtk_text_buffer_get_iter_at_line (bufferconst, &end, i+1);
gtk_text_buffer_insert (bufferconst, &start, old_new, -1);
}
gtk_text_buffer_get_start_iter (bufferconst, &start);
gtk_text_buffer_get_end_iter (bufferconst, &end);
gtk_text_buffer_apply_tag_by_name (bufferconst, "centrar", &start, &end);
}
}
}
else
{
dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, //Lo que imprime la
ventana de informacion
GTK_MESSAGE_INFO,
GTK_BUTTONS_CLOSE,
"\n\nAntes de Ejecutar, debe Compilar Exitosamente el
Proyecto");
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER); // Posicion de
la ventana de dialogo
gtk_dialog_run (GTK_DIALOG (dialog));
// Corre el dialogo
gtk_widget_destroy (dialog);
}
}
/*-----------------------------------------------------------------------------------*/
/***********************************INTERRUPCION**************************************
/
/*-----------------------------------------------------------------------------------*/
void on_button_stop (GtkButton * button, gpointer user_data)
{
158
Detener=1;
}
void on_button_stop_position (GtkButton * button, gpointer user_data)
{
char *s;
string str="$";
To_posicion = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(user_data));
compiler compilador;
str = str + compilador.convert_to_string(Pos_VM, 16, 4);
s = string_to_char(str);
if(To_posicion)
{
gtk_button_set_label(GTK_BUTTON(user_data), s);
}
else{
gtk_button_set_label(GTK_BUTTON(user_data), "Parar en");
Pos_VM = 65535;
}
}
void on_button_stop_point (GtkButton * button, gpointer user_data) // Devuelve el valor del boton donde se
desea detener
{
// la ejecucion del programa
Pos_VM = gtk_spin_button_get_value (GTK_SPIN_BUTTON(user_data));
// Si se desea que
devuelva un double
// Pos_VM = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON(user_data)); // Si se desea que
devuelva un int
}
/*-----------------------------------------------------------------------------------*/
/**********************************Cerrar Ventanas************************************/
/*-----------------------------------------------------------------------------------*/
void close_regs (GtkWidget *wid, GtkWidget *win)
{
vm_closed = 0;
vm_created = 0;
gtk_window_set_destroy_with_parent (GTK_WINDOW(win), TRUE);
}
void close_win (GtkWidget *wid, GtkWidget *win)
{
vm_closed = 0;
vm_created = 0;
gtk_window_set_destroy_with_parent (GTK_WINDOW(win), TRUE);
}
/**************************************************************************************/
/**************************************************************************************/
/***************************************FIN********************************************/
/**************************************************************************************/
/**************************************************************************************/
159
ANEXOS
Librerías necesarias para la compilación y ejecución del programa en Linux y que
pueden ser instaladas desde el gestor de paquetes de Synaptic:
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
libart2.24-cil
libatk1.0-0
libcairo2
libcairomm-1.0-1
libglade2.0-cil
libglademm-2.4-1c2a
libglib2.0-0
libglib2.0-cil
libgnome2-0
libgnome2.24-cil
libgtk2.0-0
libgtk2.0-cil
libgtkspell0
libgtk-vnc-1.0-0
libpango1.0-0
libpangomm-1.4-1
Además, es importante el paquete: php-gtk_2.0.0-1_i386.deb, que puede ser
descargado desde Internet.
Existe además el paquete “libgtk2.0-dev_2.16.1-0ubuntu2_i386.deb” para Ubuntu
que instala todas las librerias mencionadas anteriormente y está disponible en la dirección:
https://launchpad.net/ubuntu/karmic/i386/libgtk2.0-dev/2.16.1-0ubuntu2, al 30 de julio del
2009.
Para compilar el simulador completo para la CPUCR, basta con escribir “make” sin
comillas, desde la terminal de Linux, ubicándose sobre la carpeta donde están contenidos
los archivos del programa.
160
Para crear un programa con GTK desde Microsoft Windows, puede utilizarse el
tutorial disponible en las direcciones web (es el mismo tutorial para las dos direciones):
• http://lubriotech.blogspot.com/2005/10/trabajando-con-dev-c-y-gtk-bajo.html
• http://lubriotech.blogspot.com/