Informe - Escuela de Ingeniería Eléctrica

Transcripción

Universidad de Costa Rica
Facultad de Ingeniería
Escuela de Ingeniería Eléctrica
IE – 0502 Proyecto Eléctrico
UCRASM entorno de diseño de programación para
ensamblador NASM con el set de instrucciones
IA32
Por:
Emmanuel Barrantes Chaves
Ciudad Universitaria Rodrigo Facio
Agosto del 2011
UCRASM entorno de diseño de programación para
ensamblador NASM con el set de instrucciones
IA32
Por:
Emmanuel Barrantes Chaves
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:
_________________________________
M.Sc. Enrique Coen Alfaro
Profesor Guía
_________________________________
Ing. Daniel Díaz Bolaños
Profesor lector
_________________________________
Ing. Diego Valverde G.
Profesor lector
ii
DEDICATORIA
A Dios que me ha dado todo lo que tengo y
a mis padres, soy lo que soy gracias a ellos.
iii
RECONOCIMIENTOS
Al profesor Daniel Díaz, este proyecto
se finalizo gracias a el.
iv
ÍNDICE GENERAL
DEDICATORIA............................................................................................III
RECONOCIMIENTOS................................................................................IV
NOMENCLATURA......................................................................................XI
RESUMEN....................................................................................................XII
CAPÍTULO 1 : INTRODUCCIÓN ...............................................................1
Objetivos...................................................................................................3
Objetivo general...................................................................................................3
Objetivos específicos............................................................................................3
Metodología..............................................................................................4
CAPÍTULO 2: DESARROLLO TEÓRICO.................................................5
Sistema operativo GNU/Linux Ubuntu..................................................5
Origen...................................................................................................................5
Proyecto GNU......................................................................................................9
Características Linux..........................................................................................11
Filosofía GNU....................................................................................................12
v
Situación actual de merado Linux......................................................................13
Ubuntu................................................................................................................14
C++..........................................................................................................15
Code:: Blocks..........................................................................................16
Origen.................................................................................................................17
Instalación..........................................................................................................17
WxWidgets.........................................................................................................19
IDE...........................................................................................................22
Nasm........................................................................................................23
Instalación..........................................................................................................26
CAPÍTULO 3: INTERFAZ GRÁFICA.......................................................28
Proyecto...................................................................................................28
Construcción gráfica..............................................................................34
Pestañas..............................................................................................................35
Projects..............................................................................................................36
Symbols.............................................................................................................37
Resources...........................................................................................................37
Widgets...............................................................................................................37
Editor de la barra de menú.................................................................................41
vi
CAPÍTULO 4: CLASE Y FUNCIONES IMPLEMENTADAS.................44
TRIE........................................................................................................44
Push....................................................................................................................45
CheckNC............................................................................................................47
CheckC...............................................................................................................47
OnQuit.....................................................................................................47
OnAbout..................................................................................................48
OnClose...................................................................................................48
Abrir........................................................................................................49
Nuevo.......................................................................................................50
Guardar...................................................................................................51
GuardarComo........................................................................................51
CargarDicc..............................................................................................52
CargarReg...............................................................................................52
Revisarlinea............................................................................................53
RevisarTodo............................................................................................54
Compilar.................................................................................................55
vii
Correr......................................................................................................56
CompyCor...............................................................................................57
Check.......................................................................................................57
CAPÍTULO 5: CONCLUSIONES Y RECOMENDACIONES................59
Conclusiones...........................................................................................59
Recomendaciones...................................................................................60
BIBLIOGRAFÍA............................................................................................61
GLOSARIO....................................................................................................62
ANEXOS.........................................................................................................65
viii
ÍNDICE DE FIGURAS
Figura 2.1 Cuota del mercado en computadoras11.........................................................14
Figura 2.2 Instalación manual...........................................................................................18
Figura 2.3 Instalación automática.....................................................................................19
Figura 3.1 Nuevo proyecto.................................................................................................28
Figura 3.2 proyecto wxWidgets parte 1............................................................................29
Figura 3.9 Ventana del Proyecto........................................................................................35
Figura 3.10 Una vez agregado wxNotebook.....................................................................38
Figura 3.11 Después de agregar el wxStaticText..............................................................39
Figura 3.12 Después de agregar el wxTextCtrl................................................................40
Figura 3.13 Editor de la barra de menú............................................................................41
Figura 3.14 Editor de la barra de menú............................................................................43
Figura 4.1 Árbol binario y TRIE.......................................................................................45
ix
Figura 4.2 TRIE ejemplo después de insertar “pul”.......................................................46
Figura 4.3 TRIE después de la palabra “pull”.................................................................46
Figura 4.4 Selector de archivos..........................................................................................48
Figura 4.5 Selector de archivos..........................................................................................49
Figura 4.6 Nueva pestaña ..................................................................................................50
Figura 4.7 Texto resaltado..................................................................................................54
x
NOMENCLATURA
GNU: Es un acrónimo recursivo que significa “GNU No es Unix”, y se refiere al sistema
operativo completo de software libre.
GUI: Este acrónimo se refiera a la interfaz gráfica, Graphic User Interface por sus siglas en
ingles.
HTTP:Hypertext Transfer Protocol es un protocolo que se utiliza en todas las transacciones
en la internet.
NASM: Es un lenguaje de programación en ensamblador y es un acrónimo para Netwide
Assembler.
SO: es acrónimo utilizado para Sistema Operativo, y esto es un conjunto de programas
realizando funciones en un sistema informático.
xi
RESUMEN
El proyecto se realizó con el objetivo principal de brindar una herramienta, para la
programación bajo el lenguaje NASM. El programa debía presentar una interfaz gráfica que
fuera amigable con el usuario y ser fácil de utilizar.
Se investigó acerca del lenguaje C++ y las biblioteca wxWidgets, para poder
cumplir con todos los objetivos del proyecto. Se utilizó el programa Code::Blocks, el cual
resultó ser un mediador entre el lenguaje y la biblioteca.
Luego de la investigación se procedió con la codificación del programa UCRASM,
se realizaron pruebas exhaustivas y a su ves se realizaron las correcciones pertinentes. La
aplicación fue desarrollada bajo la plataforma GNU/Linux en la distribución Ubuntu de 32
bits y Ubuntu de 64 bits. Esta sirvió como base para el desarrollo de todo el proyecto y
como entorno de pruebas de la aplicación. El tipo de pruebas fueron tanto funcionales como
pruebas destructivas, es decir, se probó que el programa realizara todas las funciones
descritas en este documento, como probar la reacción del programa a errores intencionales.
El programa tiene potencial para crecer, se le pueden realizar mejoras que salen de
los objetivos de este proyecto. Se podría mejorar la interfaz gráfica, de tal manera que el
programa se aún mas agradable para el usuario, también se podría expandir el programa
para que no solo reconozca el set de instrucciones IA32 sino también instrucciones de 64
bits.
xii
1 Capítulo 1 : Introducción
El presente proyecto pretende desarrollar un programa que realice funciones
comunes de un IDE(integrated development environment) por sus siglas en ingles, el cual
es un programa que otorga al usuario una interfaz amigable para desarrollar algún lenguaje
de programación, en este caso sera el lenguaje de programación ensamblador libre para la
plataforma Intel x86 llamado Nasm.
La utilización de editores de texto comunes con los que se escribe actualmente
código para Nasm, representan un obstáculo para la programación. Estas herramientas son
muy poco flexibles y no representan ninguna ayuda para la programación de este lenguaje
La necesidad de sustituir los editores de texto comunes, e implementar una
herramienta capaz de facilitar al usuario dicha programación es la razón que impulso este
proyecto. Además en algunos cursos, del plan de estudio de la carrera Ingeniería Eléctrica
con énfasis en Computadoras y Redes se utiliza este lenguaje en la realización de
proyectos, tareas y exámenes para los cuales esta aplicación puede brindar una gran ayuda.
El proyecto desarrollado se distribuye bajo la licencia GPL, esta licencia implica
que cualquier persona es libre de utilizar, estudiar, modificar o ajustar el programa, siempre
que la nueva aplicación desarrollada se distribuya bajo la misma licencia.
1
2
El proyecto fue elaborado en su totalidad sobre la plataforma de software libre
llamada Ubuntu, el cual es una distribución de GNU/Linux. Edemas de la plataforma se
utilizaron la aplicación Code::Blocks y se desarrolló en el lenguaje de programación C++.
Code::Blocks es una herramienta que facilita la creación de entornos gráficos de
programas, para poder hacerlos amigable con el usuario. Este tiene una licencia que permite
una libre copia y distribución, la cual es GPL versión 3. La lógica del programa y sus
funciones fueron implementadas en programas en C++.
La aplicación desarrollada cuenta con opciones de crear, compilar y corres
documentos desde el programa ya que esto representa un ahorro de tiempo, en el desarrollo
y prueba del documento, además que esto representa otra mejora y un motivo mas para la
utilización de este programa en vez de de un editor de texto común.
3
1.1
Objetivos
1.1.1 Objetivo general

Diseñar un Entorno de Desarrollo Integrado (IDE) para el lenguaje de programación
ensamblador NASM.
1.1.2 Objetivos específicos

Proporcionar a los usuarios una herramienta solida que permita facilitar la
programación y aprendizaje del ensamblador NASM, por medio de la señalización
de errores sintácticos, y marcación de instrucciones.

Implementar un entorno gráfico que haga que la utilización del programa sea mas
agradable para el usuario, utilizando el
Entorno de Desarrollo Integrado
Code::Blocks y C++.

Implementar opciones de crear, compilar y correr documentos con formato “asm”,
desde el programa y no desde la terminal de Linux, esto facilitara la manipulación y
prueba de estos documentos.
4
1.2
Metodología
Para el desarrollo de este proyecto se investigó sobre el manejo y la creación de
estructuras gráficas bajo el ambiente de creación gráfico Code::Blocks, y plantillas de
proyecto de WxWidgets. Se consideró que estas herramientas cumplieran todas las
opciones necesarias para llevar a cabo el proyecto correctamente, de modo que no fuera
necesario otro programa.
Luego de implementar el entorno gráfico, se procedió a realizar la lógica detrás de
ese entorno gráfico, esto es otorgando funciones a cada uno de los widgets. Como por
ejemplo resaltar los comandos del lenguaje nasm con forme se fuera utilizando la barra
espaciadora o la tecla “enter”. Para las opciones de compilar y correr los documentos, se
tuvo que investigar sobre la utilización de Code::Blocks y la terminal de Linux. Una vez
profundizado en el tema se crearon las opciones.
Al haber terminado el programa se procedió a crear un proceso de verificación del
mismo, con la intención de encontrar fallas, faltas y errores, mas conocidos como pulgas.
Por cada elemento del programa se realizaron pruebas y se provocaron errores para
observar como el programa reaccionaba a estos y los manejaba. Luego de este proceso se
presentó el programa a compañeros estudiantes con el fin de una ultima purgación de fallas,
faltas y errores. Ya que como los compañeros no conocían la estructura del programa,
representan una forma de prueba no realizada con anterioridad. Después de estas pruebas se
dio como finalizado el programa.
2 CAPÍTULO 2: Desarrollo teórico
2.1
Sistema operativo GNU/Linux Ubuntu
2.1.1 Origen
El desarrollo del sistema operativo GNU/Linux esta casi totalmente ligado al
sistema UNIX. El cual empieza a mostrarse gracias al desarrollo de un proyecto iniciado en
1968, llamado MULTICS(Multiplexed Information and Computing System, sistema
multiplexado de información y computación).1
En aquella época un grupo de investigadores de General Electric, AT&T Bell y el
MIT(Massachussets Institute of Technology, Instituto Tecnológico de Massachussets) se
unieron para desarrollar un sistema operativo que contara con los nuevos conceptos de
multitarea, gestión de archivos y la interacción con el usuario. El problema con este
proyecto fue que resultó ser muy ambicioso, por lo que no se logró su finalización y se
abandono luego de ciertos contratiempos y retrasos.1
Después se retoma el proyecto y en 1969 conduce al desarrollo del sistema
operativo UNIX, desarrollo encabezado principalmente por Ken Thompson y Dennis
Ritchie junto con algunos otros investigadores que pertenecieron al proyecto MULTICS.
Este sistema operativo, el cual en el momento tenia el nombre de UNICS, se implementó
5
6
por primera vez en una computadora DEC PDP-7. El nombre UNIC( Uniplexed
Information and Computing System, sistema uniplexado de información y computación)
hace referencia a su predecesor el proyecto MULTICS, solo que en este proyecto solo
podía soportar dos usuarios simultáneamente. En 1970 el nombre sufre un cambio y pasa a
llamarse UNIX, nombre con el que este sistema operativo es conocido actualmente.
Al inicio el código de UNIX estaba escrito en lenguaje ensamblador, sin embargo
esto representaba una poca portabilidad, o sea era difícil de trasladar este sistema operativo
a diferentes computadoras y el código dependía del tipo de maquina. Para 1973 Dennis
Ritchie, uno de los creadores del lenguaje C, junto con Ken Thompson crearon un proyecto
para escribir de nuevo el código de UNIX pero esta vez en el lenguaje C. Esto aumento
bastante su atractivo ya que fue el primer sistema operativo en ser escrito en un lenguaje de
alto nivel. Gracias a esto era posible portar el sistema operativo a diferentes computadoras
realizando pocas modificaciones, lo único que se requería era hacer una compilación en la
maquina destino.
Debido a su creciente demanda los laboratorios Bell, cambiaron la forma en que se
distribuía este sistema operativo, ya que paso de ser de forma gratuita y con el objetivo
principal de la investigación, a ser de forma oficial concediendo licencias a los usuarios.
Hasta en 1974 los laboratorios Bell empezó a utilizar UNIX de forma masiva.
La Universidad de California en Berkeley, comenzó a aportar nuevas características
al sistema operativo convirtiéndolo en un estándar En 1975 Ken Thompson creo su propia
7
versión del sistema operativo llamada BSD(Berkeley Software Distribution, distribución de
software de Berkeley). Bill Joy y Chuck Haley, estudiantes graduados, fueron los
principales contribuidores a esta nueva versión, aportaron el editor de texto “vi” y el editor
de texto “ex”, un compilador en Pascal y el Shell C entre otras. Gracias a esto BSD paso a
ser el principal competidor con los laboratorios Bell.1
BSD pasa a ser la base de un proyecto de la DARPA(Defense Advanced Research
Projects Agency, Proyectos de Investigación Avanzada del Departamento de Defensa) a
finales de los años setenta.
Fue en 1982 que se realiza el primer lanzamiento de una versión comercial del
sistema operativo UNIX, por los laboratorios Bell y esta versión posee el nombre de
Sistema III. En 1983 AT&T presenta el sistema operativo UNIX Sistema V versión 1,
además AT&T prometió a sus usuarios total compatibilidad con las próximas versiones de
sus sistemas UNIX.
BSD versión 4.2 es lanzada por Berkeley en 1983, su principal característica, era
que podía manejar conexiones con protocolos TCP/IP, protocolos que todavía se utilizan.
Esta característica produjo un gran impacto en la demanda, produjo que esta versión fuera
adoptada por varios fabricantes de computadoras, como por ejemplo Sun MicroSystems
compañía fundada por Bill Joy, lo que luego da lugar a SunOS.
En 1980 sale al mercado una versión llamada XENIX introducida por Microsoft, la
cual dio un gran aporte ya que permitió un acercamiento de UNIX a las plataformas PC.
8
Después en 1987 Microsoft y AT&T hacen una fusión de XENIX con UNIX Sistema V,
dando como resultado la versión 3.2 de UNIX Sistema V. Lo que permitió que un sistema
UNIX estuviera disponible para una gran variedad de computadoras.
Sin embargo todas estas diferentes versiones de UNIX provocaban muchos
problemas de incompatibilidad, debido a sus grandes diferencias, lo que hacia que los
programadores tuvieran que crear distintas versiones de sus programas para cada una de las
versiones de UNIX. Gracias a esto los laboratorios Bell intentan hacer una unificación, para
poder aumentar la portabilidad de los programas en las distintas versiones de UNIX, en la
década de los ochenta. El objetivo era tomar lo mejor de cada una de las mejores versiones
de la época, y hacer un solo sistema operativo. Se tomó UNIX Sistema V(AT&T),
XENIX(Microsoft), SunOS(Microsystems), formando UNIX Sistema V versión 4, y con
esto se minimizo las versiones a dos, Sistema V y BSD.
Una organización independiente formada por usuarios del sistema UNIX llamada
/usr/group, tenia como objetivo principal aumentar la portabilidad de los programas para
UNIX. En 1985 esta organización publica el estándar POSIX(Portable Operating System
Interface for Computer Environment, Interfaz de Sistema Operativo Portable para Entornos
de Computadoras).
9
Actualmente existen versiones diferentes de UNIX como:

Solaris: Creado por Sun Microsystems, esta basada en la versión de
UNIX Sistema V versión 2. Es soportada por las plataformas Power PC,
Intel y SPARC.

AIX: Basada en la versión UNIX Sistema V versión 3 y BSD 4.3,
soportada por plataformas IBM y Power PC.

A/UX: Versión de la Apple de UNIX.

HP-UX: Creada por Hewlett-Packard, basada en la versión UNIX
Sistema V versión 2.

IRIX: Basada en al versión UNIX Sistema V versión 4, realizada por
Silicon Graphics.

SCO UNIX: Realizada por Santa Cruz Operation (SCO), basada en la
versión UNIX Sistema V versión 3.2.

Linux: Inicio como un proyecto de Linus Torvalds en la universidad de
Helsinki al inicio de los años noventa.
2.1.2 Proyecto GNU
Conforme aumentaba la popularidad de UNIX en el mercado, así iban terminando
sus distribuciones gratuitas, la ultima empresa en dar distribuciones gratuitas fue AT&T.
AT&T facilitaba el sistema UNIX gratuitamente a las Universidades, con el objetivo de su
estudio, ya que a AT&T no se le permitía estar en el mercado de las computadoras. El
10
código fuente dejó de aportarse junto con el sistema UNIX, esto fue el detonante que llevo
a Andrew Tannenbaum a programar su propio clon de UNIX, el cual fue llamado Minix.
El objetivo principal de este clon era la pedagogía, ya que Andrew Tannenbaum lo utilizaba
en su clases en la Universidad Libre de Ámsterdam.
Este clon cumplía con varias
características tales como no ser excesivamente complejo pero contar con las ultimas
novedades de la tecnología, que existiera la posibilidad que los estudiantes pudieran
disponer de él en sus casas. Sin embargo esto solo cubría las necesidades de la Universidad
Libre de Ámsterdam, y como UNIX dejo de ser gratuito las organizaciones tenían que
pagar por él. Por lo que se inició el proyecto GNU, con el cual se deseaba crear un sistema
portable, gratuito, avanzado, que facilitara el código fuente al publico y con un aspecto
similar a UNIX. Los programas de este proyecto se debía distribuir con la licencia
GPL(General Public License, Licencia Pública General), la cual daba a los usuarios la
capacidad de distribuir copias sin ningún tipo de problema, además de la posibilidad de
modificar el código fuente con la condición de mantener el copyright del programa. Los
programas del proyecto GNU son parecidos a los programas comerciales y en muchos
casos los superan en calidad, gracias a la Internet estos programas se han difundido y con
esto se facilita la creación de los mismos, ya que miles de voluntarios alrededor del planeta
llevan a cabo este proyecto.
Linus Torvalds creo un pequeño núcleo a partir de algún clon de UNIX como un
proyecto de investigación, al inicio de los años noventa. Luego de pulir su diseño
11
distribuyó su versión bajo al licencia GPL, invitando a la personas a probarlo y mejorarlo.
Coloco en uno de los foros de Usenet el siguiente mensaje:
“¿Echa de menos aquellos días de Minix 1.1, cuando los hombres eran hombres y
escribían sus propios controladores de dispositivos? ¿No tiene ningún proyecto
interesante y se muere de ganas de hincarle el diente a un sistema operativo que
pueda modificar para ajustarlo a sus propias necesidades? ¿Encuentra frustrante
que todo funcione en su sistema operativo? ¿Ya no pasa noches en vela intentando
configurar un ridículo programa? Entonces este mensaje puede ser justamente
para usted.“ 1
2.1.3 Características Linux
Linux posee varias ventajas sobre los otros sistemas actuales como por ejemplos:

Es muy consistente: quiere decir que la manera en que se utiliza no varia mucho de
función en función, por ejemplo las ordenes siempre tienen la misma sintaxis.

Dispone de aplicaciones muy potentes.

Es estable y robusto: independiza los procesos diferentes de tal forma que si uno
deja de funcionar no obstruya el correcto funcionamiento de los demás.

Es muy compatible con el trabajo con redes de computadoras.

Portabilidad: se puede utilizar en diferentes plataformas.
12

Aprovechamiento de los recursos: con pocos recursos Linux puede dar excelentes
resultados.

Amplia documentación: que cubre todas las secciones del sistema, además se puede
obtener ayuda de otros usuarios por medio de Internet.
2.1.4 Filosofía GNU
El pilar principal que sostiene la filosofía GNU es la licencia Copyleft. Existen
usuarios que toman un programa regido bajo la licencia de software libre, modifican un
poco o nada el programa, y lo comercializan como software privativo. El objetivo principal
del método Copyleft es impedir que ocurran casos como el mencionado anteriormente.
Copyleft es un método general para hacer que los programas redistribuidos, ya sean
modificados o no, deban ser distribuidos con total libertad, tal y como el creador del
programa original lo distribuyo, o sea el nuevo programa debe contar con la misma libertad
del programa padre. Copyleft garantiza esta libertad de los programas.1
El nombre Copyleft se deriva de la intención del mismo, o sea que va en dirección
contraria a lo que es el Copyright. Copyright quita la libertad a los usuarios, por otro lado
Copyleft otorga esta libertad, como se observa siguen direcciones contrarias .
Todas las licencias están diseñadas de tal manera que se puedan copiar fácilmente a
los nuevos programas. Solo se debe incluir una copia de la licencia, sin modificar, en la
documentación del nuevo programa.
13
2.1.5 Situación actual de merado Linux
Linux presenta presenta crecimiento en algunos sectores del mercado actual, sin
embargo esta todavía por debajo del dominante del mercado, Windows. En la Figura 2.1 se
observa la distribución del mercado de los sistemas operativos para el año 2008, se puede
ver que Linux es dueño del tercer tercer lugar en el mercado. El dominio del mercado, por
parte de Windows, se debe a los siguientes aspectos:

La costumbre: Muchos usuarios no desean probar nuevos sistemas operativos, por
lo engorroso que representa aprender a utilizar uno nuevo.

Al perfil de los usuario: Existen usuarios que simplemente por sus empleos o
estudios, no tienen otra opción mas que utilizar Windows.

Educación: A los estudiantes tanto de primaria como secundaria e inclusive a los
universitarios se les enseña a trabajar bajo Windows. Esto esta cambiando por lo
menos para los estudiantes universitarios.

Juegos: Los juegos representan una parte importante en el mercado de
computadoras, y existen muchos que no se pueden portar a otros sistemas
operativos, por lo que los usuarios deben utilizar Windows para jugar con ellos.6
14
Figura 2.1 Cuota del mercado en computadoras11
En cuanto a servidores Linux(Apache) domina el mercado, en los últimos 14 años
Linux a llegado a alcanzar el 72% de consumo, mientras que Windows lo máximo que
alcanzó fue el 36%.
2.1.6 Ubuntu
Ubuntu es un sistema operativo basado en otro sistema operativo de Linux,
“Debian”, Ubuntu también tiene como núcleo a Linux. La empresa Canonical da soporte
técnico a Ubuntu. Esta empresa es privada y fue fundada por Mark Shuttleworth.9
Una ves que Linux se estableció en el año 2004, el software libre todavía no era una
opción para todos los usuarios, es por esto que Mark Shuttleworth junto con un grupo de
diseñadores del proyecto “Debian”, construyeron un entorno de Linux fácil de utilizar para
todo tipo de usuarios, llamado Ubuntu. Ubuntu viene de una palabra antigua de África que
15
significa “Igualdad/Lealtad a los demás”, también quiere decir “Soy lo que soy, por lo que
todos son”.9
Una diferencia fundamental entre Ubuntu y las versiones comerciales de Linux, es
que Ubuntu no divide el esfuerzo en una versión comercial de alta calidad y una versión
gratis de una calidad pobre .
La primera versión de Ubuntu fue la 4.10 llamada “Warty Warthog” fue liberada en
Octubre del 2004, el siguiente año se vio un gran crecimiento en la comunidad de Ubuntu.
Hoy en día Ubuntu es libre y seguirá siendo así, además Ubuntu esta creciendo no solo en
el mercado de software para computadores sino para otros tipos de sistemas como teléfonos
celulares.
2.2
C++
C es un lenguaje compilado, evoluciono de BCPL y B. BCPL.BCPL fue
desarrollado por Martin Richards en 1967, y su objetivo principal era tener un lenguaje para
escribir software y crear compiladores para sistemas operativos. BCPL y B. BCPL tenían
como característica principal el que sus datos no tuvieran tipo, o sea que todas las variables
poseían el mismo tamaño en memoria, por lo que era responsabilidad del programador
tratar el dato de la manera que mas le conviniera.2
C fue derivado de B por Dennis Ritchie en 1972. En sus inicios se dio a conocer
porque fue el lenguaje con el que se desarrollo UNIX, actualmente todos los sistemas están
escritos en lenguaje C y/o C++. Uno de sus atractivos es la portabilidad, esto es gracias a
16
que C es independiente del Hardware, puede ser compilado en casi todas las computadoras.
A finales de los años setenta, ya se había establecido un C “tradicional”, sin
embargo conforme se expandía C en las diferentes plataformas, lo cual producían
problemas de compatibilidad, por lo que en 1983 se creo el comité técnico X3J11 bajo el
American National Standard Committee on Computer and Information Processing , con la
intención de definir un estándar no ambiguo. En 1989 aprobaron el estándar que se conoce
como ANSI/ISO 9899:1990.
C++ fue diseñado por Bjarne Stroustrup en 1983 en los Laboratorios Bell, y es un
superconjunto del lenguaje C. Aporto nuevas características que hacen mas atractivo el
lenguaje C, la principal es que adhiere la capacidad de llevar a cabo la programación
orientado a objetos.2
2.3
Code:: Blocks
Code::Blocks es un programa, de código abierto, que facilita la creación de
interfaces gráficas para códigos escritos en C/C++. Code::Blocks fue desarrollado bajo el
lenguaje C++. Este programa presenta herramientas para crear y modificar ventanas,
botones, menús, paneles, etiquetas y todas aquellas partes de un programa con las que
interactúa el usuario.
17
2.3.1 Origen
Los diseñadores de Code::Blocks presentaron dos versiones , la versión 1.0rc1, la
cual fue presentada el 25 de Julio del 2005 y la versión 1.0rc2, la cual fue presentada el 25
de Octubre del 2005. Sin embargo la segunda versión no fue bien recibida por los usuarios,
por lo que en ves de presentar una versión final, los diseñadores optaron por presentar
actualizaciones diarias llamadas "nightly builds"(construcciones nocturnas), esto permitía a
los usuarios proporcionar comentarios o quejas de la actualizaciones, y se podían corregir
para la siguiente actualización, esto produjo la sensación de que el proyecto estaba
estancado, es decir se había quedado en una versión definitiva.
El 28 de febrero del 2008, se presento la primera versión estable, esta versión fue la
8.02, el nombre se debe a la fecha de presentación, el 8 corresponde al año y el 02
corresponde al mes. Actualmente la versión disponible de Code::Blocks es la versión 10.05.
2.3.2 Instalación
Existen varias alternativas para la instalación, de las cuales solo se explicaran dos,
descargando
el
instalador
de
la
pagina
oficial,
la
cual
es
http://www.codeblocks.org/downloads, y utilizando Centro de software de Ubuntu.
Para llevar a cabo la instalación con la primera opción se debe visitar la pagina
oficial de Code::Blocks http://www.codeblocks.org/ en la sección de descargas, se
selecciona la sección de archivos binarios, luego se busca el archivo comprimido
18
“codeblocks-XX.XX-1-debian-YYYYY.tar.bz2”(XX.XX
representa
la
versión
de
Code::Blocks, YYYY representa el tipo de plataforma en el que se desea instalar
Code:Blocks. Si se desea instalar en 32-bits se usa “i386”, si se desea instalar en 64-bits se
utiliza “amd64”).
Una vez terminada la descarga, se debe descomprimir el archivo, obteniendo una
carpeta llamada amd64 dentro de la cual existen varios archivos .deb, solo se le debe dar
doble click a cada uno de los archivos. Se desplegara una ventana del Centro de software de
Ubuntu como en la Figura 2.2.
Otra forma instalar los archivos .deb, es utilizando una terminal, posicionarse en el
directorio donde se encuentran los archivos .deb y ejecutar el comando “sudo dpkg -i
*deb”, con esto automáticamente se instalaran todos los archivos .deb.
Figura 2.2 Instalación manual
Existe una forma de instalación automática, solo se debe ingresar al programa
Centro de software de Ubuntu, buscar programas por el nombre Code::Blocks, dar click en
19
el botón que dice “Más información” aparece una ventana similar a la de la Figura 2.3,
para finalizar solo se da click al botón Instalar y se espera a que la instalación finalice.
Figura 2.3 Instalación automática
2.3.3 WxWidgets
WxWidgets es un conjunto de bibliotecas de C++ que permite desarrollar y crear
interfaces gráficas para aplicaciones, tanto para Windows, Linux y UNIX en arquitecturas
de 32 bits y 64 bits, como para arquitecturas de celulares como Windows Mobile y iPhone
SDK.12
WxWidgets representa una forma sencilla de crear interfaces gráficas para
aplicaciones en distintas plataformas, la facilidad que presenta es que la aplicación siempre
va a tener widgets que combinan con la configuración gráfica de la plataforma, por ejemplo
20
si el usuario le cambia los colores a todas las ventanas, la ventana de la aplicación también
cambiara de color.
Las principales características que ofrece wxWidgets son la ayuda en línea, la
programación de redes, subir y guardar imágenes en una variedad de formatos y soporte de
base de datos.
El proyecto wxWidgets nace en 1992 por Julian Smart en el Artificial Intelligence
Applications Institute(Instituto de las Aplicaciones de la Inteligencia Artificial) de la
Universidad de Edinburgh.9
Conforme pasó el tiempo, una pequeña pero entusiasta comunidad de los usuarios
de wxWidgets, se estableció aportando contribuciones y reparaciones, las contribuciones
mas grandes eran por parte de los usuarios de plataformas Mac. WxWidgets fue obteniendo
mas y mas usuarios alrededor del mundo. Estos usuarios pertenecían al sector tanto
comercial, gubernamental como industrial, estos pensaban que wxWidgets ofrecía un mejor
producto, un mejor soporte que los productos comerciales de la época
En 1996 wxWidgets se estanco un poco, Julian dejó el Artificial Intelligence
Applications Institute para ser un consultor independiente, después de eso se liberaron
pocas versiones. Lo que parecía un avance incontenible de Java estaba produciendo dudas
con respecto al futuro de las bibliotecas de C++. Gracias a muchas contribuciones el código
de wxWidgets llego a verse cansado y con necesidad de un replanteamiento. Al inicio de
1997 se dio este replanteamiento, comprometiéndose a hacer de wxWidgets lo
21
suficientemente flexible para las futuras y actuales tendencias, con mas widgets y un mejor
uso de C++.9
Ya para el final de 1997 Julian Smart empezó
a distribuir CD-ROMs de
wxWidgets. Para versión wxWidgets 2.1.11 se observa los impresionantes atributos de la
clase wxHTML de Vaclav Slavik, incluía impresión y vista . WxHTML daba acceso a una
forma fácil ver texto con formato, además daba la capacidad de presentar reportes.
Para instalar wxWidgets solo es necesario instalar Code::Blocks ya que, wxWidgets
es parte fundamental de Code::Blocks. O si se desea se puede utilizar el programa “Gestor
de Paquetes Synaptic”, en la barra de búsqueda escribir “wxwidgets” e instalar los
siguientes paquetes(X.X representa la versión a instalar):

wxX.X-headers

libwxgtkX.X-0

wx-common

libwxgtkX.X-dev

libwxgtkX.X-dbg

libwxbaseX.X-0

libwxbaseX.X-dev

libwxbaseX.X-dbg
22
2.4
IDE
Un IDE es un programa que da herramientas a los desarrolladores de software para
facilitar su labor al programar. Comúnmente un IDE debe contar con cuatro características
las cuales son:

Un editor de código fuente.

Un compilador o interprete.

Herramientas para la ejecución automática.

Una herramienta para encontrar errores en el código.
Los primeros sistemas de programación se realizaban con tarjetas programadas, y
cintas magnéticas entre otros. Es por esto que cuando sale la primera consola o terminal
también aparece el primer IDE, el cual se controlaba desde terminal. El primer lenguaje de
programación en ser creado con un IDE fue “Dartmouth BASIC”. Este IDE tenia la
capacidad para editar y crear archivos, compilación, ejecución y herramienta para encontrar
errores, a pesar de que este IDE se manejaba vía comandos a través de la terminal y no
como los IDEs actuales que poseen interfaces gráficas.10
Maestro I es el nombre del primer IDE del mundo, fue creado por Softlab Munich
en 1975. Maestro I fue el líder en el mundo durante los años setenta, hoy en día se puede
encontrar un Maestro I en el museo de información y tecnología de Arlington. Otro IDE en
ser de los primeros en el mundo fue Softbench.9
Algunos IDEs que se pueden encontrar actualmente en la red son:
23

C/C++: NetBeans, Bloodshed, Kdevelop y Eclipse CDT.

Python: Komodo, NetBeans, PyCharm, WingIde, PyScripter, Pyshield y IEP.

Perl: Epic, Open Perl IDE, Optiperl, Kephra, Gvim y Emacs.

Java: Jcreator, IntelliJIDEA, NetBeans, Jedit, NEDit y BlueJ.

Masm: Winasm y Radasm.
2.5
Nasm
Netwide Assembler o Nasm es un lenguaje ensamblador, creado con la intención de
aportar mas portabilidad y modularidad. Soporta todas las extensiones de arquitectura x86
conocidas, como por ejemplo x86−64 , también soporta macros. Soporta varios tipos de
formatos de archivos tales como .out, elf, COFF, Mach−O . Fue diseñado para que la
sintaxis fuera sencilla de entender, muy parecida a la sintaxis de Intel, un poco menos
complejo.
Nasm surgió de la necesidad de tener un lenguaje ensamblador que cumpliera con
aspectos que los lenguajes ensamblador de la época no podían satisfacer. En ese momento
estaba el lenguaje “a86”, era un buen ensamblador pero no era gratis, tenia el problema de
que no tenia compatibilidad con 32-bit a menos que se pagara esta opción, y solo sirve para
Windows. Gas es otro ensamblador de la época el cual era gratis y soportado tanto para
Windows como para Linux, pero su corrección de errores era mínima, tenía una sintaxis no
atractiva y no tenia una compatibilidad adecuada con 16-bits.
24
El “as86”, fue ensamblador de la época que no satisfacía las necesidades. Tenia el
problema de que no existía suficiente documentación.
Masm era un ensamblador caro, malo y que solo se ejecuta en Windows.
Tasm contaba con una sintaxis que era esencialmente Masm, ya que Tasm se
esforzaba por tener compatibilidad con Masm lo que significaba muchas directivas y
tramites. Además era caro y solo se podía utilizar bajo la plataforma Windows.
Los problemas anotados anteriormente hicieron que creciera la necesidad de un
ensamblador que fuera gratis, con una sintaxis sencilla y que corriera en ambas plataformas
Windows y Linux.
El lenguaje NASM posee una licencia de software libre llamada “BSD license”. La
cual permite la redistribución del código fuente, ya sea con o sin modificación, siempre y
cuando cumpla con las siguientes reglas:

La redistribución del código fuente debe conservar el siguiente aviso copyright,
Copyright 1996−2011 the NASM Authors – All rights reserved.

Se debe adjuntar la siguiente renuncia:
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
25
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES;
LOSS
OF
USE,
DATA,
OR
PROFITS;
OR
BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE. 4
Lo cual significa:
Este este software es proporcionado por los derechos de autor y colaboradores "tal
cual" y ninguna garantía expresa o implícita, incluyendo, pero no limitada, a las
garantías de comercialización y aptitud para un propósito particular es rechazada.
En ningún caso el propietario del copyright o los colaboradores son responsables
por daños directos, indirectos, accidentales, especiales, ejemplares, o derivados
(incluyendo sin limitar, a la obtención de bienes o servicios, la pérdida de uso, de
datos o de beneficios, o interrupción), como en cualquier teoría de responsabilidad,
ya sea contrato, estricta responsabilidad, o agravio (incluyendo negligencia)
derivados de alguna manera a partir del uso de este software, incluso si se ha
advertido de la posibilidad de tales daños.
26
2.5.1 Instalación
A continuación se explican los pasos para tener una versión estable de Nasm
instalada en Linux.
Se
debe
descargar,
de
la
pagina
oficial
de
Nasm
http://www.nasm.us/pub/nasm/releasebuilds/?C=M;O=D, un archivo comprimido llamado
nasm−XXX.tar.gz donde XXX significa el numero de la versión que esta en el archivo.
Una vez descargado, se descomprime en el directorio /usr/local/src, una vez descomprimido
se creara una carpeta con el nombre “nasm−XXX”.
Una ventaja de la configuración de Nasm es que es automática, por lo que nada mas
se debe abrir una terminal, cambiar de directorio hacia la carpeta “nasm−XXX” con el
siguiente comando:
cd /usr/local/src/nasm−XXX
(Recordar cambiar XXX por la versión que se va a utilizar)
Luego se ejecuta el script “configure” con el siguiente comando:
./configure
Lo que hace este script es encontrar el mejor compilador de C para construir Nasm y
preparar los makefiles correspondientes.
Después de la autoconfiguración se debe escribir la palabra “make” en la terminal
para construir los archivos binarios “nasm” y “ndisasm”. Para finalizar se debe escribir el
comando:
make install
27
El cual instalara los archivos binario en /usr/local/bin e instalara manuales nasm.1 y
ndisasm.1 en /usr/local/man/man1. Y con esto ya se puede tener Nasm instalado en Linux.
3. CAPÍTULO 3: Interfaz gráfica
La interfaz gráfica representa una parte muy importa de este proyecto, esta es la que
permite que el programa sea amigable con el usuario. La interfaz gráfica se llevó a cabo por
medio de Code::Blocks y wxWidgets, herramientas útiles en la creación de interfaces
gráficas para aplicaciones. En este capitulo se explicara como se desarrolló la interfaz paso
a paso.
3.1Proyecto
Para crear un proyecto nuevo, se debe abrir el programa Code::Blocks, en la barra
de menú seleccionar la pestaña que dice “New”, luego seleccionar “Project”, aparecerá una
ventana igual a la Figura 3.1. En esta ventana aparecen las opciones de widgets con los que
sea desea trabajar, en este caso es wxWidgets entonces se selecciona el icono con el
nombre “wxWidgets project”.
Figura 3.1 Nuevo proyecto
28
29
En la primer ventana(Figura 3.2) aparece solo es un mensaje de bienvenida, para
avanzar es necesario dar clic en el botón “Next”.
Figura 3.2 proyecto wxWidgets parte 1
La ventana siguiente es para seleccionar la versión de wxWidgets con la que se va a
trabajar, en la ventana se mostraran las versiones de wxWidgets que se tienen instaladas en
el computador.
30
Para este proyecto se seleccionó la versión 2.8.x porque era la ultima versión estable
disponible en el momento de crear el proyecto.
En la Figura 3.4 se observa la siguiente ventana en aparecer, en esta se deben llenar
los datos del proyecto las casillas corresponden a el titulo del proyecto, ubicación del
proyecto (carpeta en donde se va a guardar la carpeta que contiene todos los archivos para
el proyecto), nombre del archivo del proyecto y en la ultima casilla se presenta la ubicación
del nombre del archivo del proyecto. Los cambios realizados en las primeras 3 casillas
modifican automáticamente a la ultima.
La cuarta ventana en aparecer se llena con información del autor de la aplicación,
llenar las casillas en esta ventana es opcional, por lo que se puede avanzar a ala siguiente
ventana al darle clic en “Next”. La información que se escriba en esta ventana(Figura 3.5)
31
será colocada al inicio de cada código fuente que sera creado al finalizar la creación del
proyecto.
En la Figura 3.6 se puede ver la ventana siguiente se debe seleccionar una entre los
dos tipos de interfaz gráfica de usuario(GUI por sus siglas en ingles), para este proyecto se
seleccionó wxSmith ya que es la GUI que soporta más widgets. Además hay que
seleccionar el tipo de aplicación que se va crear, existen dos posibilidades tipo Dialog y
tipo Frame. Para este proyecto se utilizo tipo Frame, debido a que el uso de este tipo hace
que la ventana ya tenga la base de un menú, en la sección 3.2 se dará mas detalles al
respecto.
32
En la siguiente ventana(Figura 3.7) no se debe modificar absolutamente nada, sin
embargo para mas información en esta ventana se selecciona el compilador, la dirección en
donde se creara el ejecutable final y la dirección en donde se crearan los archivos .o, los
cuales son archivos temporales de la compilación.
33
En la ultima ventana no se debe cambiar nada, en este ventana se habilitan opciones
avanzadas, pero esto es para los diseñadores mas experimentados, las necesidades de este
proyecto se satisfacen con las opciones por defecto. La ventana se presenta en la Figura 3.8.
34
Al darle clic al botón “Finish” se crearan en la carpeta seleccionada en la Figura 3.4
los siguientes archivos: XXX.cbp, XXX.depend, XXX.layout, XXXApp.cpp, XXXApp.h,
XXXMain.cpp, XXXMain.h. Dentro de un carpeta llamada “wxsmith” debe haber un
archivo llamado “XXXframe.wxs”. Si se encuentran todos estos archivos el proyecto se
creo correctamente. Recordar que en ves de XXX debe estar el nombre del proyecto, para
efectos de este proyecto de ahora en adelante se cambiaran las XXX por UCRASM.
3.2Construcción gráfica
Una de las razones del porque se eligió wxSmith en ves de wxFormBuilder en la
ventana de la Figura 3.6, es que wxSmith trae un pequeño menú por defecto, en esta
35
sección se explicara como manipular la ventana del proyecto y como mejorar el menú que
esta incluido en wxSmith.
Una vez creado el proyecto se abrirá una ventana similar a la mostrada en la Figura
3.9. En la cual se denotan cuatro rectángulos de colores rojo, azul, verde y amarillo, estos
rectángulos muestran las partes principales que se utilizaron en la creación de este proyecto
Figura 3.9 Ventana del Proyecto
3.2.1
Pestañas
En la Figura 3.9 se puede observar tres pestañas, encerradas en un rectángulo rojo,
las cuales son : “Projects”, “Symbols”, “Resources”.
36
3.2.1.1
Projects
En esta pestaña se encuentran los códigos fuente de C++ utilizados en la
construcción del proyecto. UCRASMApp.cpp contiene el programa que empieza toda la
parte gráfica en este código fuente no se debe modificar nada. En UCRASMMain.cpp
representa el programa principal del proyecto, contiene las definiciones de las funciones
que se utilizan en el programa, inicialmente solo tiene el constructor, el destructor, la
función OnQuit y la función OnAbout. En el constructor de la clase no se debe escribir
nada entre el texto “ //(*Initialize(UCRASMFrame) ” y “ //*) ” ya que todo lo que se
escriba ahí, se borrara la próxima ves que se actualicen los widgets. En el constructor
también se guardan la definición de los widgets.
UCRASMApp.h y
UCRASMMain.h son los códigos fuentes las cabeceras de
UCRASMApp.cpp y UCRASMMain.cpp respectivamente, esto significa que en ellos se
guarda la declaración de las clases y de las funciones de cada clase, UCRASMFrame es la
clase que se declara en UCRASMMain.h y UCRASMApp es la clase que se declara en
UCRASMApp.h. Por último se encuentra UCRASMframe.wxs es un código fuente que no
se puede modificar manualmente, conforme se hacen cambios en los widgets se va
actualizando este archivo.
37
3.2.1.2
Symbols
Se pueden ver las funciones que se definen y las variables en esta pestaña. Es una
forma de accesar a esta información mas rápidamente, en caso de que el código sea muy
largo, así se evita perdidas de tiempo. Para brincar a la declaración nada mas se da doble
clic sobre el nombre de la variable o función, y en la pantalla se desplegara el código en
donde se declara.
3.2.1.3
Resources
En la Figura 3.9 se observa donde se selecciona los widgets encerrado por un
rectángulo amarillo, esta junto con la pestaña “Resources” se utilizan para crear y modificar
la interfaz gráfica.
3.2.2
Widgets
Para empezar a crear la interfaz gráfica se debe abrir el archivo, que se encuentra en la
pestaña “Projects”, llamado “UCRASMframe.wxs”, al darle doble clic la parte derecha
cambiara y se presenta como la parte derecha de la Figura 3.9, donde hay un rectángulo con
un fondo blanco con puntos, este es el marco de trabajo. Además se mostrará el
seleccionador de widgets, el cual aparece encerrado por un rectángulo amarillo(Figura 3.9),
tiene varias pestañas con diferentes tipos de widgets. Luego se debe dar clic en la pestaña
“Resources”.
38
Lo primero que se agrega es un widget llamado “wxNotebook”, se encuentra en la
pestaña “Standard” en el seleccionador de widgets, esto se logra dando clic en el botón del
“wxNotebook” y luego dar clic en el marco de trabajo. El widget “wxNotebook” lo que
permite es que se almacenan otros widgets en forma de pestañas. Tiene que verse como en
la Figura 3.10
Figura 3.10 Una vez agregado wxNotebook
Luego se agrega el widget “wxStaticText” que se encuentra en la pestaña
“Standard” en el seleccionador de widgets, de la misma manera que se hizo con el
“wxNotebook”, nada mas que en ves de darle clic al escritorio de trabajo se le da al
“wxNotebook”. El “wxStaticText” se utiliza para mostrar los errores sintácticos que haya a
la hora de compilar.
A este widget se le cambian ciertas características , esto se hace modificando las
casillas que se encuentran encerradas en un rectángulo verde en la Figura 3.9, llamado
39
manejador. Se da clic en el widget al que se le quiere modificar las características , el
manejador cambia dependiendo del widget seleccionado.
Se le debe borrar la casilla “Label”, esto hace que al iniciar el programa no aparezca
nada escrito en el widget “wxStaticText”, en la casilla “Page name” se cambia por “Build
Log”, esto le cambia el nombre permanentemente a la pestaña del widget “wxStaticText”, y
en la casilla “Foreground” se cambia “default” por “Active window caption”, esto hace que
el texto que se escriba aparezca de diferente color. Después de esto debe quedar iguala ala
Figura 3.11
Figura 3.11 Después de agregar el wxStaticText
Para finalizar la interfaz gráfica se le agrega un widget “wxTextCtrl” que se
encuentra en la pestaña “Standard” en el seleccionador de widgets, se hace de la misma
manera que con el “wxStaticText”. “wxTextCtrl” es el widget que da la opción de editar
texto,sin embargo por defecto es una entrada de texto de una sola línea por lo que hay que
40
modificarle ciertas características. En el manejador se modifican las siguientes casillas: la
casilla “Text” se debe borrar, la casilla “Page name” se debe cambiar el contenido por
“Code”, se le debe dar clic a la casilla “Hidden” de tal forma que se agregue un check en
esa casilla, y en la casilla “Style” se deben activar las opciones: wxTE_MULTILINE,
wxTE_RICH, wxTE_RICH2, wxHSCROLL, wxVSCROLL. Estas características lo que
permiten es cambiar una entrada de texto de solo una línea por una entrada de texto
multilínea, que soporte mucho texto, o sea que la longitud máxima sea muy grande, además
permiten que en caso de que el texto es mas grande que la ventana aparezcan barras vertical
y horizontal que permitan al usuario moverse por el texto. Luego de agregar la entrada de
texto y modificarle las características debe observarse como en la Figura 3.12
Figura 3.12 Después de agregar el wxTextCtrl
41
3.2.3
Editor de la barra de menú
Para modificar el menú que por defecto ya esta en el proyecto por haber elegido
wxSmith, se le debe dar doble clic al icono izquierdo que aparece encerrado por un
rectángulo azul en la Figura 3.9, en ese momento se despliega una ventana nueva igual a la
de la Figura 3.13, donde se muestra al lado izquierdo los menús y botones que existen, y al
lado derecho muestra las características de esos menús y botones.
Figura 3.13 Editor de la barra de menú
Para agregar un ítem nuevo se da clic en el botón “New”, con los botones que
contienen flechas y están arriba del botón “New”, se cambia la posición del ítem en la barra
de menú. Con las flechas arriba y abajo, se modifica la posición vertical dentro de la barra
de menú, y con las flechas derecha e izquierda se modifica el ítem, es decir se decide si el
ítem es un menú o un botón. Por ejemplo si a un menú se le mueve hacia la derecha el
42
menú se convierte en un botón, y si a un botón se le mueve hacia la izquierda se convierte
en menú.
Cuando se agrega un ítem se le debe crear un “Id”, eso se logra escribiendo un
nombre en la casilla que dice “Id”, además en la casilla que dice “Label” se llena con el
nombre que se desee para el ítem. La casilla “Accelerator” da la facilidad de escribir una
secuencia de teclas que aceleren un botón, por ejemplo para este proyecto en vez de tener
que buscar en el menú el botón “New” con solo presionar la tecla “F2” se ejecuta la misma
función.
Para este proyecto se agregaron dos menús: “Options” y “Build”. También se
agregó el botón “Refresh” en el menú “Options” , los botones “Check” “Compile” “Run”
“Compile and Run” en el menú “Build” y los botones “New”, “Open”, “Save”,
“SaveAs....”, “Close”, “Exit” en el menú “File”. En la Figura 3.14 se muestra el menú
finalizado.
43
Figura 3.14 Editor de la barra de menú
4. CAPÍTULO 4: Clase y funciones implementadas
Además de la interfaz gráfica el programa tenia que tener código que se ocupara de
manera la parte lógica detrás de la interfaz gráfica, manejar la función de los menús, que se
resaltará el código que se escribiera en la entrada de texto, que se imprimiera la salida en
“Build Log” en caso de errores, etc. Se tuvieron que crear funciones que manejaran toda la
lógica, estas funciones se encuentran declaradas en UCRASMMain.h y definidas en
UCRASMMain.cpp. Fue necesario implementar una clase especial llamada “TRIE”, es una
clase que sirve principalmente para hacer un diccionario
4.1TRIE
TRIE es una estructura de datos que sirve para almacenar cadenas de letras, su
nombre viene de la palabra recuperación en ingles(retrieval). Su estructura es muy similar
a la de un árbol binario, la diferencia es que un nodo(una unidad de almacenamiento de una
estructura de datos) de un TRIE puede tener mas de dos hijos. En la Figura 4.1 se muestra
las dos estructuras, la del lado izquierdo es el árbol binario y la otra es el TRIE. En el TRIE
de la Figura 4.1 se pueden formar 3 palabras con el mismo inicio “pusha”, “pushs”,
“pushf”, además se observa que el ultimo nodo “h” tiene 3 hijos, en realidad un nodo de un
TRIE puede tener hasta 26 hijos ya que este es el número de letras disponibles en el
alfabeto.
44
45
Figura 4.1 Árbol binario y TRIE
Para utilizar el TRIE se creó las funciones “Push”, “CheckC” y “CheckNC”.
4.1.1
Push
“Push”guarda una palabra en el TRIE, por ejemplo si desea guardar la palabra
“pull” en el TRIE de la Figura 4.1. Se verifica si la “p” ya esta en el TRIE, como sí esta se
verifica si la “u” también esta en el TRIE pero tiene que estar después de la “p” en el TRIE,
luego se verifica si la “l” esta en el TRIE después de “pu” como no esta se crea un nodo con
contenido “l” la Figura 4.2 muestra como esta el TRIE después de insertar la “l”.
46
Figura 4.2 TRIE ejemplo después de insertar “pul”
Para la otra “l” de la palabra “pull” ocurre un caso especial, ya que es la ultima letra
de la palabra, entonces al crear el nodo para la “l” se le agrega una característica, llamada
“final”, que indica si el nodo es el ultimo nodo de alguna palabra esto con el objeto de que
“p”,“pu” y “pul” no representen palabras. En la Figura 4.3 se observa la palabra “pull” ya
almacenada en el TRIE.
Figura 4.3 TRIE después de la palabra “pull”
47
4.1.2
CheckNC
Esta función verifica si una palabra se encuentra en el TRIE pero sin tomar en
cuenta mayúsculas y minúsculas. Por ejemplo se desea saber si la palabra “push” esta en el
TRIE de la Figura 4.3. Primero se verifica que se encuentre la letra “p”, como esta se
verifica que ese nodo tenga un hijo con la letra “u”, y a su ves que el ultimo tenga un hijo
con la letra “s”, por ultimo se verifica si el nodo “s” tenga un hijo con la letra “h” y que
además tenga la característica “final” activada, por lo tanto “push” si se encuentra, pero si
se buscara la palabra “pus” sucedería que el nodo “s” no tiene la característica “final”
activada por lo que “pus” no es una palabra valida en el TRIE.
4.1.3
CheckC
Esta función actúa de forma similar a “CheckNC” con la diferencia que si la palabra
a verificar esta en minúscula y aunque su semejante en mayúscula esta en el TRIE, esta
función diría que no se encuentra la palabra. O sea si se busca “push” y en el TRIE esta
“PUSH”, se diría que “push” no se encuentra en el TRIE.
4.2OnQuit
Esta es una función sencilla, es llamada cada vez que el usuario presiona el botón
“Exit” del menú “File” ó el usuario presiona las teclas “Alt + F4”. Cuando la función es
48
llamada ejecuta el comando “exit(0)”. “exit” es una función de la biblioteca “cstdlib” y lo
que hace es terminar el programa normalmente, o sea sin dar ninguna alerta de error.
4.3OnAbout
Es llamada cuando el usuario presiona el botón “About” en el menú “Help” ó
cuando el usuario presiona la tecla “F1”. La función lo que hace es mostrar en una nueva
ventana el mensaje “Made by Emmanuel Barrantes with wxWidgets 2.8.11-Linux-Unicode
build”, la ventan tiene como titulo “Credits”. En la Figura 4.4 se observa la ventana que
aparece al ser llamada esta función.
Figura 4.4 Selector de archivos
4.4OnClose
“OnClose” es llamada cuando el usuario presiona el botón “Close” en el menú
“File” ó cuando el usuario presiona las teclas “Alt + X” ó cuando el usuario presiona el
botón con una “x”, que sirve por lo general para cerrar ventanas. La función verifica que
pestaña el usuario esta tratando de cerrar, si la pestaña es la “Build Log” la función termina
49
el programa, en caso de que sea cualquier otra pestaña la función cierra dicha pestaña y el
programa se sigue ejecutando.
4.5Abrir
Esta función se llama cuando el usuario presiona el botón “Open” en el menú “File”
ó cuando el usuario presiona las teclas “Alt + O” . Al ser llamada esta función desplegara
una ventana donde el usuario puede seleccionar cualquier archivo, la cual se observa en la
Figura 4.5.
Figura 4.5 Selector de archivos
Una vez seleccionado el archivo se abre en modo lectura, luego se crea una pestaña
nueva en el widget “wxNotebook” y la función toma el nombre del archivo para cambiar el
50
titulo de dicha pestaña, después copia todo el contenido del archivo en la nueva pestaña. Al
final llama a la función “RevisarTodo” y cierra el archivo.
4.6Nuevo
Sencillamente esta función crea una nueva pestaña vacía en el widget
“wxNotebook”, y como titulo de la pestaña se escribe la palabra “nuevo”. Para llamar a
esta función, el usuario debe presionar el botón “New” en el menú “File” ó debe presionar
la tecla “F2”. La Figura 4.6 muestra el resultado luego de haberse ejecutado esta función.
Figura 4.6 Nueva pestaña
51
4.7Guardar
Esta función verifica en cual pestaña se esta intentando guardar el contenido, en
caso de que sea la pestaña “Build Log”, la función no realiza ninguna acción, si la pestaña
es una pestaña nueva, no existe un archivo destino en donde se va a guardar el contenido de
la pestaña, por lo que se despliega una ventana para seleccionar el nombre con el que se va
a guardar la pestaña nueva.
En caso de que la pestaña no sea nueva, es decir una pestaña producida por una
función “Abrir”, dicho de otra manera una pestaña que se haya guardado con anterioridad,
lo que significa que ya se tiene el nombre del archivo destino donde se va a guardar el
contenido de la pestaña. En cualquiera de las opciones anteriores, una vez que se tiene el
nombre del archivo destino, se copia el contenido de la pestaña en el archivo, y se cambia
el nombre de la pestaña por el nombre del archivo destino.
Para llamar a esta función el usuario puede presionar el botón “Save” en el menú
“File” ó puede presionar las teclas “Alt + S”.
4.8GuardarComo
Para esta función no importa cual pestaña se vaya a guardar, se puede guardar tanto
una pestaña normal o la pestaña “Build Log”. Una vez llamada, la función despliega una
ventana donde el usuario debe elegir, el nombre con el que se va a guardar el contenido de
la pestaña, luego de que se seleccione, se cambia el titulo de la pestaña por el nombre del
52
archivo elegido. El usuario puede utilizar esta función si presiona el botón “SaveAs....” en
el menú “File” ó puede presionar las teclas “Alt + Shift + S”.
4.9CargarDicc
Esta función busca un archivo llamado “Instrucciones” que debe estar en la misma
carpeta en donde se encuentra el ejecutable “UCRASM”. Si no lo encuentra lo crea, en él
debe encontrarse el repertorio de instrucciones IA32 del lenguaje ensamblador, debe haber
solo una instrucción por línea y las instrucciones deben estar en mayúscula. La función
toma todas las instrucciones del archivo “Instrucciones” y las guarda en una variable
llamada “Diccionario”, esta variable es del tipo TRIE, es decir la función ejecuta el
comando “push” que tiene la clase TRIE, y luego cierra el archivo “Instrucciones”. El
usuario no puede utilizar esta función, cada vez que se inicia el programa por si solo se
llama a esta función.
4.10
CargarReg
Similar que la función “CargarDicc”, solo que en ves de cargar instrucciones esta
función carga los registros del set de instrucciones IA32. De igual manera que en la función
“CargarDicc” esta función busca en la carpeta donde se encuentra el ejecutable, el archivo
se llama “Registros”, en él se debe encontrar los registros, uno por línea, y en mayúscula. Si
el archivo no existe la función lo crea.
53
Los registros que se encuentran en el archivo “Registros” se guardan en una
variable llamada “Registros” y también es del tipo TRIE al final de la función se cierra el
archivo “Registros”. Al igual que en la función “CargarDicc” esta función nunca es llamada
por el usuario, solo se llama una vez al inicio del programa.
4.11
Revisarlinea
Es la función que se encarga de resaltar las instrucciones, registro y comentarios. Si el
usuario hace algún tipo cambio en el texto de alguna de las pestañas, se llamara
automáticamente a la función, el usuario no puede llamar a la función directamente, solo a
través de los cambios que haga en el texto.
Al inicio la función creara unas variables que contiene diferentes colores, estos
colores se utilizaran para cambiar el color de las palabras, solo se cambiaran las palabras
que estén en el diccionario. Estos colores son rojo, azul y verde. Luego se obtiene la línea
en donde el usuario haya realizado un cambio, se separan las palabras de la línea por medio
de los espacios y se almacenan. Si se encuentra un “;” esto significa que es un comentario
por lo que se almacena todo el resto como una sola palabra.
Luego se evalúa palabra por palabra de la línea, primero se verifica si es una
instrucción, un registro, o comentario. En caso de que sea alguna de estas opciones se
cambia el tipo de letra y el color dependiendo de lo que sea la palabra, si es una instrucción
se cambia por azul, si es un registro se cambia por rojo, y si es cualquier otra palabra se
cambia el color por negro. En la Figura 4.7 se observa un ejemplo como queda resaltado el
54
texto en una pestaña, en la Figura se observa que después de un “;” sin importar el texto
que haya queda de color verde.
Figura 4.7 Texto resaltado
4.12
RevisarTodo
Esta función es llamada cuando se abre un archivo, el objetivo es revisar todo el
texto que se acaba de abrir para ver si hay instrucciones, registro y/o comentarios. LA
función recorre línea por línea y ejecuta la función revisar línea. El usuario sí puede utilizar
manualmente esta función, solo debe presionar el botón “Refresh” que se encuentra en el
menú “Options”.
55
4.13
Compilar
Esta función se encarga de crear un ejecutable del programa que se escribió en
ensamblador en una pestaña, utilizando Nasm, el archivo a compilar debe tener una
terminación .asm. El usuario puede hacer uso de esta función si presiona el botón
“Compile” que se encuentra en el menú “Build” ó si presiona las teclas “Ctrl + F9”.
La función primero verifica que el usuario no este intentando compilar la pestaña
“Build Log”, en caso de que sí el programa simplemente no hace ninguna acción, una vez
que se reconoce cual pestaña esta intentando compilar, se verifica que la pestaña ya haya
sido guardada al menos una vez, en caso de que la pestaña sea nueva se despliega una
ventana donde el usuario puede elegir un archivo para compilar. De la pestaña o el archivo
que se intenta compilar, se obtiene el nombre y la ubicación, a la frase “nasm -f elf ” se le
agrega la ubicación del archivo, y a la frase “ld -m elf_i386 -o ” se le agrega el nombre del
archivo y el nombre del archivo con terminación .o . La primera frase es el comando que se
utiliza para llamar a nasm en la terminal de Linux y la segunda frase es el comando que
funciona para enlazar el archivo .o y crear el ejecutable.
Si existe un error con el comando “nasm” esta función no alertara para eso funciona
la función “Check”, pero si existe un error durante el enlazamiento, se alertara por medio
de la pestaña “Build Log”, en esta pestaña se copia todos los errores que se imprimen
normalmente en la terminal de Linux, en caso de que no exista ningún problema en la
56
compilación se imprime un mensaje en la pestaña “Build Log” que dice "Process
terminated with 0 errors" que significa que no hubo ningún error.
Para poder utilizar comandos de Linux en C++ se utilizó una función, llamada
“system”. Esta función recibe una linea con los comandos que se quieren ejecutar en una
terminal de Linux, ejecuta el comando y devuelve un numero dependiendo de como resultó
la ejecución del comando, si el comando en la terminal se ejecutó correctamente la función
devuelve un 0. Para hacer uso de esta función se debe incluir la biblioteca “cstdlib” al inicio
del código fuente.
4.14
Correr
En esta función se ejecuta un programa que ya haya sido compilado correctamente,
de manera que existe un ejecutable de esa pestaña. Para llamar a esta función el usuario
puede presionar el botón “Run” del menú “Build” ó puede presionar las teclas “Ctrl + F10”.
La función verifica que el usuario no este intentando utilizar esta función en la
pestaña “Build Log”, en caso de que sí el programa no ejecuta ninguna acción. Una vez que
se sabe cual pestaña se esta intentando ejecutar, se verifica que la pestaña ya haya sido
guardada con anterioridad al menos una vez, de esta manera se tiene un archivo destino.
En caso de que la pestaña sea nueva se despliega una ventana para que el usuario
elija un archivo, este archivo sera el archivo destino. Con el nombre del archivo destino, se
toma la ubicación del ejecutable, y se ejecuta el programa. En caso de que no exista el
57
ejecutable se imprime el error en la pestaña “Build Log” en donde se indica que el archivo
no existe, en caso contrario se imprime un mensaje en la misma pestaña, “File exists“.
4.15
CompyCor
Es una función muy sencilla que llama a las funciones “Compilar” y “Correr”, en
ese orden, en caso de que el usuario desee ejecutar las 2 funciones, sin tener que hacerlo
individualmente. Para utilizar esta función el usuario puede presionar la tecla “F9” ó puede
presionar el botón “Compile and Run” que se encuentra en el menú “Build”.
4.16
Check
Esta función le permite al usuario revisar la sintaxis de un programa en una pestaña,
sin tener que compilarlo. El usuario puede usar esta función al presionar la tecla “F8” ó
presionar el botón “Check” en el menú “Build”.
Al iniciar la función revisa que el usuario no este posicionado en la pestaña “Build
Log” porque si lo estuviera, la función no realizaría ninguna acción. Luego la función
revisa que el usuario ya haya guardado esa pestaña con anterioridad, ya que si no lo ha
hecho, se abre una ventan donde se le da la opción al usuario de elegir un programa para
revisarle la sintaxis. Se crea la frase “nasm -f elf ” y se le agrega el nombre del programa,
se le pasa como argumento a la función “system”, y si la función “system” devuelve un 0
significa que no tiene errores, pero si la función devuelve cualquier otro numero, hubo un
error de sintaxis y este se desplegara en la pestaña “Build Log”. En caso de que no exista
58
algún error se desplegara en la pestaña “Build Log” el mensaje “Process terminated with 0
errors”.
5. Capítulo 5: Conclusiones y Recomendaciones
5.1Conclusiones

Code::Blocks es en definitiva una herramienta útil que facilitó la creación de la
interfaz gráfica. Ahorrando tiempo a diferencia de haber tenido que crear la interfaz
manualmente escribiendo código de C++ utilizando la biblioteca wxWidgets.

La combinación del lenguaje C++ con la biblioteca wxWidgets resultó conveniente,
ya que el tiempo que se invirtió aprendiendo a utilizarlos fue corto y los problemas
que aparecieron durante la creación del proyecto se resolvieron con ayuda de la
comunidad en internet de C++ y wxWidgets.

Haber realizado este programa bajo el sistema operativo Ubuntu GNU/Linux ofrece
una gran ventaja, , la comunidad de Ubuntu puede realizar mejoras y puede
despulgar el programa.

El programa creado en este proyecto resulta una herramienta simple pero que
cumple con los objetivos estipulados al inicio del proyecto, además se luchó por la
optimización de recursos utilizados por el programa tanto en memoria de ejecución
del programa, como la memoria que ocupa el programa en el disco duro.
59
60
5.2Recomendaciones

La interfaz gráfica del programa cumple de manera funcional sin embargo podría
mejorarse para que sea estéticamente mas agradable para el usuario. Los botones de
los menús puede exponerse de manera diferente, como en un tipo de barra donde
cada botón tenga una Figura que refleje su funcionalidad.

Una limitante que posee el programa es que es exclusivo para el set de instrucciones
IA32, podría modificarse el programa para reconocer instrucciones y registros de 64
bits, ya que el programa aunque fue creado para IA32 fue desarrollado pensando en
posibles expansiones y mejoras.

Se puede mejorar el programa para permitir la interacción del usuario con el
programa en NASM, es decir, crear una forma de que el usuario ingrese
información como se hace en la consola de Ubuntu.

Permitir al usuario pasar parámetros antes de correr un programa, existen programas
donde el usuario debe pasar datos al dar la orden de correr al programa, pro ejemplo
./ “nombre del programa” dato1 dato2.
61
BIBLIOGRAFÍA
1. Catalina Gallego M., Catalina Gallego A. “Unix/Linux Iniciación y referencia”,
McGraw Hill, España, 1999.
2. Deitel H.M., Deitel P.J., “Como programar en C/C++”, Prentice Hall, México,
1994.
3. The NASM Development Team . “NASM — The Netwide Assembler ”, 2011.
4. Canes M., Llamas J. , Rodríguez A., Gasparin L., “Estado del software libre en
el mundo Libre”, http://studies.ac.upc.edu/ALE/ILSLD/PRES1.pdf .
5. Stallman R., “What is Copyleft?”,
http://www.gnu.org/philosophy/philosophy.es.html .
6. http://en.wikipedia.org/wiki/Code::Blocks.
7. Ollivier K.,“History of wxWidgets”, http://www.wxwidgets.org/about/history.htm.
8. http://en.wikipedia.org/wiki/Integrated_development_environment.
9. http://www.ubuntu.com/project/about-ubuntu
10.
http://www.translationdirectory.com/articles/article1702.php
11. Ollivier Kevin ,http://www.wxwidgets.org/
12.
ALEGSA - Santa Fe, Argentina.http://www.alegsa.com.ar/Dic/plataforma.php
62
Glosario
Árbol binario: Es una estructura de almacenamiento que se utiliza al programar en ciertos
lenguajes, para poder llamar a una estructura de esta manera debe satisfacer la regla de que
un nodo solo debe de tener dos nodos hijos.
Apache: Es un servidor HTTP de código abierto.
Bibliotecas: Son códigos y datos que facilitan una labor para un lenguaje de programación.
Bit: Unidad mas pequeña en el sistema de numeración binaria.
Clases: Es un tipo de datos en programación, que puede contener valores, variables,
funciones y estructuras de datos.
Código fuente: Es un archivo con lineas de texto, las cuales poseen instrucciones para la
computadora, que indican como ejecutar un programa.
Compilador: Programa que crea otro programa desde un código fuente.
Constructor: Sirve para inicializar un objeto cuando es creado al programar.
Despulgar: Realizar pruebas con la intención de buscar fallas, faltas y errores en un
programa.
Destructor: Sirve para eliminar objetos en una clase.
Enlazar un programa: Crear un acceso directo a un programa, en Linux
Hardware: Es la parte física de un sistema electrónico.
Instanciar: Es la acción de llamar a una clase durante un programa.
Java: Es un lenguaje de programación creado por Sun Microsystems, similar a C y C++.
63
Lenguaje compilado: Es un lenguaje de programación que utiliza un compilador.
Lenguaje ensamblador: Lenguaje de programación de bajo nivel,
varia según la
arquitectura de la computadora.
Macros: Secciones de código que se utilizan para ahorrar tiempo al programador. El
programador solo escribir el macro una vez. Luego solo necesitara escribir el nombre de un
macro en vez de repetir el código varias veces.
Makefile: Es una herramienta para automatizar código en los sistemas Linux, es un código
con instrucciones que normalmente se utilizan en la terminal.
Nodo: Unidad de almacenamiento en estructuras de datos.
Objeto: Es la instancia de una clase.
Plataformas PC: Es un sistema informático que hace funcionar bloques tanto de hardware
como de software.
Programación orientada a objetos: Un tipo de programación que usa objetos.
Pulgas: Es un nombre que se le da a los errores, faltas y fallas en los programas.
Script: Archivo de texto plano, el cual contiene instrucciones para el sistema operativo.
Shell C: lenguaje de programación desarrollado por Bill Joy, sintaxis similar a la de C. Es
utilizado en Linux.
Software: Es la parte lógica de un sistema informático.
Software privativo: Cualquier programa en donde el usuario posee limitaciones en el uso,
distribución, modificación, y copia del programa.
64
Terminal o consola: Interprete de instrucciones, sirve de interfaz entre el usuario y el
sistema Linux.
Widgets: Componente de control gráfico con el cual el usuario interactúa.
65
ANEXOS
Anexo A: Reporte de pulgas del lenguaje NASM
Se supone que el grupo de Nasm nunca libera versiones con pulgas, que ellos
conozcan, pero como cualquier programa siempre tiene pulgas, pasa que los usuarios
encuentran pulgas que el grupo Nasm desconocen, por lo que existe la alternativa de de que
los usuarios reporten estas pulgas por medio de una sección en la pagina oficial
http://www.nasm.us/, llamada "Bug Tracker".
En la sección 2.2 de la documentación oficial de Nasm se encuentra una lista de
pulgas encontradas, pero son pulgas no solucionadas ya que no afectan grandemente a
Nasm, o sea no se solucionan deliberadamente.
Para reportar una pulga se debe adjuntar la siguiente información:

El sistema operativo en el que se esta corriendo Nasm como Linux, Windows, BSD
Mac Os, etc.

La versión de Nasm que se esta corriendo, como exactamente se esta llamando a
Nasm, o sea los comando que se utilizan para utilizar Nasm.

La versión de cualquier programa suplementario que este usando junto con Nasm y
los comandos que se utiliza para llamarlos desde la terminal. Si los problemas solo
se ven a la hora de enlazar el programa, decir cual enlazador se esta utilizando, qué
versión y los comandos utilizados. Si es un compilador el que se utiliza para enlazar
66
el programa decir cual compilador se esta utilizando, qué versión y los comandos
utilizados.

Si es posible enviar el código fuente del programa en Nasm que esta teniendo
problemas. En caso de que exista problemas de copyright tenga en cuenta dos cosas:
la primera, se garantiza que cualquier código fuente que se envié para despulgar,
sera usado solo con ese fin, y luego sera borrado cualquier copia del código fuente
tan pronto como se encuentren y reparen las pulgas; segundo, el grupo Nasm
prefiere que no le envíen grandes trozos de código, entre mas pequeño mejor.

Una descripción del verdadero problema, una descripción en donde se pueda
entender fácilmente que es lo que pasa que no debería pasar, o que debería pasar, un
ejemplo puede ser: .
“NASM genera un mensaje de error diciendo que el error se encuentra en la línea 3
pero en realidad se encuentra en la línea 5”.

Si la salida que genera el programa es incorrecta también se debe enviar. Eso
ayudara a saber si el problema es de portabilidad entre plataformas.

Cualquier otra información o archivos que pueda ayudar en la búsqueda de la pulga.

Informe - Escuela de Ingeniería Eléctrica

Transcripción

Documentos relacionados

G.22 PAGINA WEB

Desde la pestaña superior en “Administración → Centros

Activación pestaña Seguridad en propiedades de carpeta

Procedimiento de Ordenes de Reparación