29-10-2014
ESTRUCTURA DE DATOS ESD-115
APLICACIÓN Y USO DE PILAS EN LENGUAJE ENSAMBLADOR
Estructuras Estructuras de Datos | Grupo 8
Tabla de contenido INTRODUCCIO INTRODUCCION. N. ..................................................................... ......................................................................................................... .................................................. .............. ii OBJETIVOS. OBJETIVOS. ....................................................................... .......................................................................................................... ........................................................ ..................... ii OBJETIVO OBJETIVO GENERAL GENERAL.................................................................. ...................................................................................................... ............................................. ......... ii OBJETIVOS OBJETIVOS ESPECIFICOS ESPECIFICOS .................................................................. ..................................................................................................... ...................................... ... ii Alcances Alcances del Proyecto. Proyecto. ....................................................................... ........................................................................................................... ....................................... ... 0 DESCRIPCION DESCRIPCION DEL TEMA. .................................................................... ....................................................................................................... ...................................... ... 1 Lenguaje Lenguaje Ensamblado Ensambladorr del Microproce Microprocesador sador.. ..................................................................... ........................................................................ ... 2 Instruccione Instruccioness de Transferen Transferencia cia de Datos. Datos. ..................................................................... .............................................................................. ......... 3 Instruccion Instrucciones es de control control de Bucles Bucles ...................................................................... .................................................................................... .............. 4 Instruccion Instrucciones es Aritméticas. Aritméticas. ....................................................................... ................................................................................................. ..........................4 Formato Formato de las Instruccio Instrucciones. nes. ....................................................................... ............................................................................................ ..................... 5 Aplicación Aplicación de pilas en Lenguaje Lenguaje Ensamblador Ensamblador.. ................................................................... ................................................................... 6 RESULTADOS RESULTADOS ESPERADOS. ESPERADOS. .................................................................. ..................................................................................................... ...................................... ...9 PLANTEAMIENT PLANTEAMIENTO O DEL PROBLEMA. PROBLEMA........................................................................................... ..........................................................................................10 ANALISIS DEL PROBLEMA. PROBLEMA. ................................................................... ...................................................................................................... ..................................... 11 DISEÑO. DISEÑO. ...................................................................... .......................................................................................................... ............................................................ ........................ 14 Operación Operación Recorrido: Recorrido: ..................................................................... ......................................................................................................... ...................................... 14 Operación Operación Push:........................................................................................ .................................................................................................................. ..........................14 Operación Operación Pop: ................................................................... ....................................................................................................... ................................................ ............15 Operación Operación Búsqueda: Búsqueda: ..................................................................... ......................................................................................................... ...................................... 15 Operación Operación Eliminar:.................. Eliminar:...................................................... ....................................................................... ....................................................... .................... 15 PRUEBAS. PRUEBAS..................................................................... ........................................................................................................ ............................................................ ........................ 17 MANUAL DE USUARIO.............................. USUARIO.................................................................. ........................................................................ ........................................... .......20 CONCLUSIONE CONCLUSIONES. S....................................................................... ......................................................................................................... ................................................ ............. 30 BIBLIOGRAFIA. BIBLIOGRAFIA. .................................................................. ..................................................................................................... ...................................................... ................... 31
Tabla de contenido INTRODUCCIO INTRODUCCION. N. ..................................................................... ......................................................................................................... .................................................. .............. ii OBJETIVOS. OBJETIVOS. ....................................................................... .......................................................................................................... ........................................................ ..................... ii OBJETIVO OBJETIVO GENERAL GENERAL.................................................................. ...................................................................................................... ............................................. ......... ii OBJETIVOS OBJETIVOS ESPECIFICOS ESPECIFICOS .................................................................. ..................................................................................................... ...................................... ... ii Alcances Alcances del Proyecto. Proyecto. ....................................................................... ........................................................................................................... ....................................... ... 0 DESCRIPCION DESCRIPCION DEL TEMA. .................................................................... ....................................................................................................... ...................................... ... 1 Lenguaje Lenguaje Ensamblado Ensambladorr del Microproce Microprocesador sador.. ..................................................................... ........................................................................ ... 2 Instruccione Instruccioness de Transferen Transferencia cia de Datos. Datos. ..................................................................... .............................................................................. ......... 3 Instruccion Instrucciones es de control control de Bucles Bucles ...................................................................... .................................................................................... .............. 4 Instruccion Instrucciones es Aritméticas. Aritméticas. ....................................................................... ................................................................................................. ..........................4 Formato Formato de las Instruccio Instrucciones. nes. ....................................................................... ............................................................................................ ..................... 5 Aplicación Aplicación de pilas en Lenguaje Lenguaje Ensamblador Ensamblador.. ................................................................... ................................................................... 6 RESULTADOS RESULTADOS ESPERADOS. ESPERADOS. .................................................................. ..................................................................................................... ...................................... ...9 PLANTEAMIENT PLANTEAMIENTO O DEL PROBLEMA. PROBLEMA........................................................................................... ..........................................................................................10 ANALISIS DEL PROBLEMA. PROBLEMA. ................................................................... ...................................................................................................... ..................................... 11 DISEÑO. DISEÑO. ...................................................................... .......................................................................................................... ............................................................ ........................ 14 Operación Operación Recorrido: Recorrido: ..................................................................... ......................................................................................................... ...................................... 14 Operación Operación Push:........................................................................................ .................................................................................................................. ..........................14 Operación Operación Pop: ................................................................... ....................................................................................................... ................................................ ............15 Operación Operación Búsqueda: Búsqueda: ..................................................................... ......................................................................................................... ...................................... 15 Operación Operación Eliminar:.................. Eliminar:...................................................... ....................................................................... ....................................................... .................... 15 PRUEBAS. PRUEBAS..................................................................... ........................................................................................................ ............................................................ ........................ 17 MANUAL DE USUARIO.............................. USUARIO.................................................................. ........................................................................ ........................................... .......20 CONCLUSIONE CONCLUSIONES. S....................................................................... ......................................................................................................... ................................................ ............. 30 BIBLIOGRAFIA. BIBLIOGRAFIA. .................................................................. ..................................................................................................... ...................................................... ................... 31
INTRODUCCION. El lenguaje ensamblador es la forma más básica de programar un microprocesador. Con la aparición de los computadores personales (PC) y la reducción de los costos de las mismas, el microprocesador se convirtió en uno de los dispositivos electrónicos más importantes en la historia de la electrónica. Básicamente un microprocesador es un circuito electrónico de muy alta escala de integración, capaza de realizar una infinidad de tareas de forma repetitiva a velocidades muy altas. El lenguaje ensamblador permite que este sea capaz de realizar realizar las tareas o los cá cálculos lculos que se le requieren. requieren. Aprender a programar en lenguaje ensamblador no es fácil, se requiere un cierto nivel de conocimiento de la arquitectura y organización de las computadoras, además del conocimiento de programación en algún otro lenguaje Las pilas son un tipo de estructura de datos que es fácil desarrollar por los sistemas microprocesadores y resulta de gran utilidad para trabajar con listas de datos y es imprescindible para el trabajo interno del microprocesador en las subrutinas e interrupciones. El nombre de PILA no es por otra cosa sino por su forma de uso, es decir, el ultimo que entra es el primero que sale, comúnmente también llamado “Last In First Out” (LIFO).
Algunos microprocesadores pueden tener la pila en su interior, representado un sistema muy rápido pero de tamaño limitado, la mayoría de microprocesadores disponen la pila en la memoria externa, hecho que proporciona una gran capacidad de almacenamiento almacenamiento y el control c ontrol de su ubicación, aunque el acceso sea más lento. Este proyecto está orientado a la aplicación y uso de las pilas en el lenguaje ensamblador, manipulando la entrada y salida de datos en una pila, utilizando las instrucciones del manejo de pilas que son dos, una para apilar un operando fuente y una para desapilar el valor que está en el tope de la pila y colocarlo en un operando distinto.
i
OBJETIVOS. OBJETIVO GENERAL
Implementar el uso de pilas en lenguaje ensamblador mediante el desarrollo de estructuras de datos en una aplicación en la que se muestre su uso en un entorno real, aplicando todos los conocimientos adquiridos. Desarrollar una simulación del uso de pilas en una aplicación basada en una calculadora en lenguaje ensamblador, utilizando el compilador MASM32.
OBJETIVOS ESPECIFICOS
Aplicar los conocimientos teóricos del uso de pilas en forma práctica para así poder identificar un escenario en el cual se implemente el uso de estas en lenguaje ensamblador.
Aprender a codificar de manera correcta en el compilador MASM32, para así poder desarrollar del escenario elegido una aplicación en un entorno real en la cual se utilice el uso de pilas.
ii
Alcances del Proyecto.
El proyecto desarrollar una aplicación programada en lenguaje ensamblador en un periodo de 3 meses en los cuales espera emular la forma en que se comportan las estructuras de datos de datos en entornos como microprocesadores o micro controladores los cuales ocupan este tipo de estructuras de datos para apilar las direcciones de datos en la arquitectura de la maquina a cual están aplicadas.
La aplicación demostrara no solo el uso de las pilas si no cómo se comportan en este nivel bajo de programación para esto se usara un lenguaje del mismo nivel como lo es el ensamblador el fin es ver como las pilas son una estructura muy útil en este tipo de entornos y como expertos programadores en lenguaje ensamblador recuren a las pilas así como otro tipo de estructura de datos para desarrollar programas que se ejecutaran más fácil y que usaran menos recursos de memoria.
En resumen el alcance principal es montar una aplicación en lenguaje ensamblador que emula cómo se comportan la estructura de datos pilas las cuales son usadas común mente a niveles de arquitectura de hardware en la asignación de memoria y como esta estructura de dato es altamente útil a la hora de desarrollar arquitectura de maquina como un Kernel o Microcontroladores.
iii
DESCRIPCION DEL TEMA. Una pila (stack en inglés) es una lista ordenada o estructura de datos en la que el modo de acceso a sus elementos es de tipo LIFO (del inglés Last In First Out , último en entrar , primero en salir ) que permite almacenar y recuperar datos. Esta estructura se aplica en multitud de ocasiones en el área de informática debido a su simplicidad y ordenación implícita de la propia estructura. Para el manejo de los datos se cuenta con dos operaciones básicas: apilar ( push), que coloca un objeto en la pila, y su operación inversa, retirar ( desapilar, pop), que retira el último elemento apilado. En cada momento sólo se tiene acceso a la parte superior de la pila, es decir, al último objeto apilado (denominado TOS, Top of Stack en inglés). La operación retirar permite la obtención de este elemento, que es retirado de la pila permitiendo el acceso al siguiente (apilado con anterioridad), que pasa a ser el nuevo TOS. Por analogía con objetos cotidianos, una operación apilar equivaldría a colocar un plato sobre una pila de platos, y una operación retirar a retirarlo.
Operaciones.
Una pila cuenta con 2 operaciones imprescindibles: apilar y desapilar, a las que en las implementaciones modernas de las pilas se suelen añadir más de uso habitual.
Crear: se crea la pila vacía. (constructor)
Tamaño: regresa el número de elementos de la pila. (size)
Apilar: se añade un elemento a la pila.(push)
Desapilar: se elimina el elemento frontal de la pila.(pop)
Cima: devuelve el elemento que está en la cima de la pila. (top o peek) 1
Vacía: devuelve cierto si la pila está sin elementos o falso en caso de que contenga uno. (empty).
Lenguaje Ensamblador del Microprocesador. La Unidad Central de Proceso (CPU, por sus siglas en inglés) tiene 14 registros internos cada uno de 16 bits. Los primeros cuatro, AX, BX, CX, y DX, son de uso general y se pueden usar también como registros de 8 bits. Es decir, AX se puede dividir en AH y AL (AH es el byte alto, high, y AL es el byte bajo, low). Lo mismo es aplicable a los otros tres (BX en BH y BL, CX en CH y CL y DX en DH y DL) Estos son los únicos registros que pueden usarse de modo dual (en 8 o 16 bits). Los registros de la CPU son conocidos por sus nombres propios, que son:
AX
(acumulador)
BX
(registro base)
CX
(registro contador)
DX
(registro de datos)
DS
(registro de segmentos de datos)
ES
(registro del segmento extra)
SS
(registro del segmento pila)
CS
(registro del segmento de código)
BP
(registro de apuntadores base)
SI
(registro de índice fuente)
DI
(registro índice destino)
SP
(registro del apuntador pila)
IP
(registro del apuntador de siguiente instrucción)
F
(registro de banderas)
El registro AX se usa para almacenar resultados, lecturas o escrituras desde o hacia los puertos- el BX sirve como apuntador base, o índice. El CX se utiliza en operaciones de iteración, como un contador que automáticamente se incrementa o decrementa de acuerdo con el tipo de instrucción usada. El DX se usa como puente para el acceso de datos. 2
El DS es un registro de segmento cuya función es actuar como policía donde se encuentran los datos. Cualquier dato, ya sea una variable inicializada o no, debe estar dentro de este segmento. El registro ES tiene el propósito general de permitir operaciones sobre cadenas, pero también puede ser una extensión del DS. El SS tiene la tarea exclusiva de manejar la posición de memoria donde se encuentra la pila (stack). Esta es una estructura usada para almacenar datos en forma temporal, tanto de un programa como de las operaciones internas de la computadora personal (PC, por sus siglas en ingles). En términos de operación interna, la CPU usa este segmento para almacenar las direcciones de retorno de las llamadas a rutinas. El registro de segmentos más importante es el CS o segmento de código. Es aquí donde se encuentra el código ejecutable de cada programa, el cual está directamente ligado a los diferentes modelos de memoria. El registro BP (base pointer) se usan para manipular la pila sin afectar al registro de segmentos SS. Es útil cuando se usa una interfaz entre lenguajes de alto nivel y el ensamblador. Puesto que dicha se basa en el concepto de la pila BP, nos permite acceder parámetros pasados sin alterar el registro de segmento SS. Los registros SI y DI son útiles para manejar bloques de cadenas en memoria, siendo el primero el índice fuente y el segundo el índice destino. En otras palabras, SI representa la dirección donde se encuentra la cadena y Di la dirección donde será copiada. El registro SP apunta a un área específica de memoria que sirve para almacenar datos bajo la estructura LIFO (ultimo en entrar, primero en salir), conocida como pila (stack). El registro de IP (intruction pointer) apunta a la siguiente instrucción que será ejecutada en memoria.
Instrucciones de Transferencia de Datos. Estas instrucciones mueven datos de una parte a otra del sistema; desde y hacia la memoria principal, de y a los registros de datos, puertos E/S y registros de segmentación. Las instrucciones de transferencias de datos son las siguientes:
MOV
transfiere
XCHG
intercambia
IN
entrada
OUT
salida
XLAT
traduce usando una tabla
LEA
carga la dirección efectiva
3
LDS
carga el segmento de datos
LES
carga el segmento extra
LAHF
carga los indicadores en AH
SAHF
guarda AH en los indicadores
PUSH FUENTE
(sp) <— fuente
POP DESTINO
destino <— (sp)
Instrucciones de control de Bucles
INC
incrementar
DEC
decrementar
LOOP
realizar un bucle
LOOPZ, LOOPE
LOOPNZ, LOOPNE
realizar un bucle si no es cero
JCXZ
salta si CX es cero.
realizar un bucle si es cero
Instrucciones Aritméticas. A. Grupo de adición:
ADD
suma
ADC
suma con acarreo
AAA
ajuste ASCII para la suma
DAA
ajuste decimal para la suma
B. Grupo de sustracción:
SUB
resta
SBB
resta con acarreo negativo
ASS
ajuste ASCII para la resta
DAS
ajuste decimal para la resta
4
C. Grupo de multiplicación:
MUL
multiplicación
IMUL
multiplicación entera
AAM
ajuste ASCII para la multiplicación
D. Grupo de división
DIV
división
IDIV
división entera
AAD
ajuste ASCII para la división
Formato de las Instrucciones. Cada instrucción en lenguaje ensamblador está compuesta por cuatro campos: Etiquetas/operación/operando/comentario El campo comentario se utiliza para propósitos de documentación y es opcional. Campo etiqueta: una etiqueta debe comenzar con un carácter alfabético y puede contener hasta 31 caracteres, incluyendo:
Letras de la A , a la Z
Números del 0 al 9
Los símbolos especiales: $. @ %
No se puede utilizar un nombre que coincida con una palabra reservada o directiva del ensamblador. Si el nombre incluye un punto, entonces el puno debe ser el primer carácter. Campo operación: contiene el nemotécnico de la instrucción, que es de 2 a 6 caracteres. Campo operando: Contiene la posición o posiciones donde están los datos que van a ser manipulados por la instrucciónCampo comentario: Se utiliza para documentar el código fuente del ensamblador. Debe separarse del ultimo capo por al menos un espacio e iniciar con ;. Cuando inicia un comentario en una línea esta deberá tener en la primera columna el carácter “;”.
5
La siguiente tabla muestra el código de selección del registro: REG REGISTRO DE 16 BITS REGISTRO DE 8 BITS 000
AX
AL
001
CX
CL
010
DX
DL
011
BX
BL
100
SP
AH
101
BP
CH
110
SI
DH
Aplicación de pilas en Lenguaje Ensamblador. El lenguaje Ensamblador es un lenguaje traductor que permite tener un control total sobre cada instrucción generada por una máquina en particular mediante el programa traductor es llamado Ensamblador. Compiladores como Pascal o C++, realizan una multitud de invisibles e inalterables procesos acerca de cómo una dada declaración del lenguaje será traducida en instrucciones de máquina. Un ensamblador tiene al menos una línea en el archivo de código fuente por cada instrucción de máquina generada. Tiene más líneas para manejar muchas otras cosas, pero cada instrucción de maquina en el archivo de código objeto final es controlada por su correspondiente línea en el archivo de código fuente. Cada una de las muchas instrucciones de maquina en el CPU tiene un mnemónico correspondiente en lenguaje ensamblador. Es necesario conocer la estructura básica de un programa escrito en lenguaje ensamblador. Básicamente nuestros programas podrían estar englobados en cuatro bloques fundamentales:
Declaraciones y definiciones.
Segmento de datos.
Segmento de pila.
6
Segmento de código.
Declaraciones y definiciones
Definición de constantes, importación de código o información al compilador.
Segmento de datos
Reserva de espacio para las variables que usa el programa. Para la creación de un segmento, se utiliza la directiva SEGMENT, la cual indica el comienzo del mismo. El segmento, en el código fuente, define un bloque de sentencias fuente, ya sean directivas o instrucciones. El final del segmento viene dado por la directiva ENDS (END Segment).
Segmento de pila
Todos los programas han de llevar pila, con el fin de depositar la información necesaria para las llamadas a funciones, o bien almacenar datos temporalmente. En este bloque se define un tamaño para la pila. El segmento de pila se define como cualquier otro segmento, pero especificando la palabra reservada STACK. En este segmento reservamos únicamente espacio para la pila, es decir, definimos su tamaño.
Segmento de código
Definición de todos los procedimientos e instrucciones del programa. Un procedimiento es un conjunto de sentencias, las cuales se engloban entre la directiva PROC (PROCedure) y la directiva ENDP (END Procedure). Instrucciones básicas de una pila en ensamblador. Instrucción POP
Propósito: Recupera un dato de la pila Sintaxis: POP destino Esta instrucción transfiere el último valor almacenado en la pila al operando destino, después incrementa en dos el registro SP. Este incremento se debe a que la pila va creciendo desde la dirección más alta de memoria del segmento hacia la más baja, y la pila solo trabaja con palabras (2 bytes), 7
entonces al incrementar en dos el registro SP realmente se le está restando dos al tamaño real de la pila.
Instrucción PUSH
Propósito: Coloca una palabra en la pila. Sintaxis: PUSH fuente La instrucción PUSH decrementa en dos el valor de SP y luego transfiere el contenido del operando fuente a la nueva dirección resultante en el registro recién modificado. El decremento en la dirección se debe a que al agregar valores a la pila ésta crece de la dirección mayor a la dirección menor del segmento, por lo tanto al restarle 2 al valor del registro SP lo que hacemos es aumentar el tamaño de la pila en dos bytes, que es la única cantidad de información que puede manejar la pila en cada entrada y salida de datos.
8
RESULTADOS ESPERADOS.
Tras haber realizado la pequeña aplicación enfocada en las funciones de la pila en un lenguaje ensamblador se espera:
Tener un manejo de los conceptos de pilas.
Conocer y manejar el proceso de una pila en el lenguaje ensamblador.
9
PLANTEAMIENTO DEL PROBLEMA. Manejo de pilas: Push y Pop. La pila es un contenedor de nodos y tiene dos operaciones básicas: push (apilar) y pop (desapilar). ‘Push’ añade un nodo a la parte superior de la pila, dejando por debajo el resto de los nodos. ‘Pop’ elimina y devuelve el actual nodo superior de la pila.
Una pila tiene muchas utilidades en programación, uno de sus usos conocidos es en la resolución de problemas algebraicos. Sin embargo, dado el nivel que los presentes tenemos del lenguaje ensamblador, hemos de plantear nuestro caso demostrar la utilidad de las pilas a nivel de lenguaje de maquina por medio del lenguaje ensamblador. Hemos de plantear la estructura con sus funciones más conocidas que mencionamos ya: push y pop.
Cada pila tiene un lugar fijo en la memoria en la que comienza, en nuestro caso hemos de añadir los datos a la pila, el puntero de pila será desplazado para indicar el estado actual de la pila, apuntando a la próxima celda, y copia el nuevo elemento de la cima en área de la pila. Desapilando es simplemente la inversa de apilar. El primer elemento es eliminado y el puntero de la pila se actualiza, en el orden opuesto de la utilizada en la operación de apilar. Tomando en cuenta lo que ya sabemos de la estructura, hemos de aplicar la pila en lenguaje ensamblador, enfocándonos en estas dos operaciones que son tan básicas en una pila, apilar y desapilar, así el programa comenzara en incluyendo unos datos en la pila y luego retirando los datos de la pila. El segundo problema sería derivar las funciones que ya conocemos de la pila, y su ejecución aplicándolo a una operación como es la de sumar.
10
ANALISIS DEL PROBLEMA. Cuando es fabricado el microcontrolador, no contiene datos en la memoria ROM. Para que pueda controlar algún proceso es necesario generar o crear y luego grabar en la EEPROM o equivalente del microcontrolador algún programa, el cual puede ser escrito en lenguaje ensamblador u otro lenguaje para microcontroladores; sin embargo, para que el programa pueda ser grabado en la memoria del microcontrolador, debe ser codificado en sistema numérico hexadecimal que es finalmente el sistema que hace trabajar al microcontrolador cuando éste es alimentado con el voltaje adecuado y asociado a dispositivos analógicos y discretos a su funcionamiento. Los datos de entrada al programa ensamblador es un fichero de texto plano que contiene un programa o secuencia de instrucciones a ejecutar por el procesador tal y como muestra la figura.
El lenguaje en el que se escribe es que ya conocemos como ensamblador. El ensamblador no solo permite utilizar los nombres de las instrucciones, operandos y modos de direccionamiento, sino también permite especificar etiquetas y definir porciones de memoria para almacenar datos. En la siguiente imagen se mostrara un fragmento del fichero que contiene uno de nuestros programas escrito en ensamblador: Los archivos deben terminar con l a extensión “ASM”. Las letras minúsculas trabajan igual que las mayúsculas.
11
Enfoquémonos en los movimientos que hacen las funciones descritas en nuestro programa: Una H después de cada número indica al ensamblador que los números son hexadecimales. El ensamblador puede confundir números con etiquetas, para evitar esto coloque un 0 (cero) antes de un número hexadecimal que inicie con una letra.
mov
ah
02h
02h es un número hexadecimal.
Instrucción MOV Transfiere un byte desde el operando fuente al operando destino. Es decir, teniendo el siguiente formato:
12
MOV • MOV
Destino • CX
Fuente • 03h
El operando fuente aparece en la instrucción, es el que mueve un valor constante a un registro interno. El direccionamiento al registro implica que el operando a ser usa está contenido en uno de los registros internos de propósito general del CPU. La instrucción anterior indica mover inmediatamente al registro CX el valor 03h. El registro interno puede ser de 1 byte o de una palabra.
13
DISEÑO. Pseudocódigo: ________________________________________
Operación Recorrido: Apuntador toma el Top, después ve si la condición cumple para efectuar un Ciclo mientras Apuntador sea diferente de Nulo, si cumple lo que hace es que despliega el contenido de la Pila(Pila[Apuntador]), después Apuntador se le resta 1. Este proceso se repite hasta que Apuntador sea igual Nulo(Cuando llega a este punto la Pila ya fue Recorrida). Recorrido(Pila, Top) Apuntador ←- Top
Repetir mientras Apuntador ≠ Nulo Imprimir Pila[Apuntador] Apuntador ←- Apuntador - 1
Fin del ciclo
Operación Push: Compara en un principio el Top con Max, si la condición no cumple es imposible insertar mas datos a la Pila, de otra forma lo que hace es Incrementar el valor de Top, y copia el valor de Elemento en Pila[Top]. De esta forma el dato ya esta insertado. Push(Pila, Top, Max, Elemento) Si Top ≠ Max Top ←- Top + 1 Pila[Top] ←- Elemento
Si no: Imprimir “Pila Llena”
Salir
14
Operación Pop: Compara para determinar si la pila esta vacío, de otra forma lo que hace es Imprimir el valor de Pila[Top] (Que es el dato que está apunto de Eliminar) y enseguida a Top le resta 1, de esta forma el dato ya no existe. Pop(Pila, Top) Si Top ≠ Nulo Imprimir Pila[Top] Top ←- Top - 1
Si no: Imprimir “Pila Vacía”
Salir
Operación Búsqueda: Busqueda(Pila, Top, Elemento) Si Top ≠ Nulo Apuntador ←- Top
Repetir mientras Apuntador ≠ Nulo Si Pila [Apuntador] = Elemento Imprimir “El Dato fue encontrado” y Salir Apuntador ←- Apuntador - 1
Fin del ciclo Imprimir “El Dato no se encontró”
Si no: Imprimir “Pila Vacía”
Salir
Operación Eliminar: El algoritmo compara para determinar si la Pila tiene algún dato, sino simplemente desplegara Pila Vacía y saldrá. De otra manera hará un Recorrido y comparara con cada uno de los Datos de la Pila hasta encontrar el dato que desea eliminar, mientras hace 15
esto copia cada uno de los datos a un arreglo Temp para cuando encuentre el Dato regresar esos valores a la Pila. Si lo encuentra desplegara “Eliminado el Dato” y le restara 1 a Top, de otra manera “El Dato no encontrado”.
Borrar (Pila, Temp, Top, Elemento) Si Top ≠ Nulo Apuntador1 ←- Top
Repetir mientras Apuntador1 ≠ Nulo Si Pila[Apuntador1] = Elemento Imprimir “Eliminando el Dato…”
Repetir mientras Apuntador2 ≠ Nulo Pila [Apuntador1]=Temp [Apuntador2] Fin del ciclo Top ←- Top - 1 y Salir
Si No: Temp [Apuntador2] ←- Pila [Apuntador1] Apuntador1 ←- Apuntador1 - 1 Apuntador2 ←- Apuntador2 + 1
Fin del ciclo Imprimir “Dato no encontrado”
Si no: Imprimir “Pila Vacía”
Salir
16
PRUEBAS. Para crear el código del programa en ensamblador, ingresamos a un editor de texto, en este caso al “Bloc de notas”.
Después de escribir el código del programa guardamos este archivo en el disco local, en la carpeta donde esté MASM y le pondremos la extensión “asm”, en nuestro caso “p.asm”
Iniciamos la ejecución de nuestro programa ingresando al símbolo del sistema. Al ingresar al símbolo del sistema buscamos el directorio en el disco local donde está guardado el MASM, utilizando el comando cd. Cuando estamos en el directorio utilizamos el comando “ml” que es el que nos permite acceder al compilador y luego ponemos el nombre de nuestro archivo creado en el block de notas, en este caso “p.asm”
Este nos genera la información del programa, y los errores si los tiene, además nos muestra dos archivos que crea, el archivo.obj y el archivo.exe. Luego escribimos el nombre de nuestro archivo creado con extensión .exe, en nuestro caso “p.exe”, y este nos muestra la ejecución del programa.
17
18
MANUAL DE USUARIO.
Compilación en ensamblador. Especificaciones del sistema: Este manual está diseñado especificaciones:
para usar en una maquina con las siguientes
Sistema operativo Windows 7 de 32 bits.
El compilador debe ser MASM6.11(previamente instalado)
Debe contar con blog de notas.
20
Pasos: Abrimos un blog de notas:
En blog de notas nos servirá para poder redactar nuestro código en leguaje ensamblador deberá de verse de esta manera.
Una vez redactado el código que deseamos compilar en lenguaje ensamblador pasamos a guardar nuestro código seleccionando la pestaña “archivo” seguido la opción “guardar como”
21
y lo nombramos de la siguiente forma “NOMBRE.asm”, importante no olvidar el “.asm” la que
este es tipo de archivos que reconoce el compilador MASM6.11.
Luego cortamos o copiamos nuestro archivo resultante que deberá verse de la siguiente forma.
Lo pegamos en la siguiente ruta: Primero abrimos equipo y damos doble clic sobre “disco local C:”
22
Luego buscamos la carpeta con el nombre MASM6.11 y damos doble clic sobre esta
Dentro de esta carpeta nuevamente buscamos otra carpeta pero esta ves con el nombre BIN y damos doble clic sobre esta.
23
Una vez dentro de esta carpeta peg amos nuestro archivo “.asm”
Una vez terminado esto cerramos la venta y presionamos el botón de inicio en el campo de búsqueda digitamos “cmd” y seleccionamos el resultado que nos da la búsqueda con el mismo nombre “cmd”.
24
Al dar doble clic debería emerger una venta de la siguiente forma y digitamos el comando “cd..” y damos ENTER.
El comando “cd..” nos permite retroceder en la ruta que nos da por defecto el cmd, luego repetimos el comando una vez mas y deber quedar esta forma “C: \>” una ves aquí digitamos “cd” pero sin “..” y luego damos espacio y escribimos MASM6.11 debe quedar de la siguiente
forma.
25
Damos ENTER y luego digitamos nuevamente “cd” y esta vez damos espacio y es cribimos “BIN”
y damos ENTER como notaran estamos creando la ruta de donde esta guardado nuestro documento con nuestro código “.asm”
Luego usaremos otro comando llamado “ml”, entonces digitamos ml damos espacio y digitamos el nombre de nuestro código que sería asa “ml NOMBRE.asm” que como ven la
imagen es ml PILA.asm. 26
Damos ENTER y es aquí donde MASM6.11 compila nuestro código y debería mostrar el siguiente mensaje.
Como podemos ver nuestro código ha sido compilado y este nos muestra que a creada un File para la corrida del programa que es terminación “.exe”.
27
Será este “.exe” será este el File que nos permitirá finalmente correr nuestro programa de la siguiente manera simplemente digitamos el nombre de nuestro programa con la terminación “.exe” como lo vimos en la imagen anterior.
Ahora simplemente damos ENTER y nuestro programa se debería ejecutar sin problemas de dar error debe ser debido a errores en el código del programa, como podemos ver la corrida de nuestro programa en este caso una pila.
28
29
CONCLUSIONES.
Hemos comprendido mejor el funcionamiento de las estructuras de una pila, así como también como se manejan en lenguaje ensamblador.
La Implementación de una pila en un lenguaje ensamblador es un bajo nivel que muchos programadores usan para programar en muchas ocasiones, más que todo en los microprocesadores que operan bajo este lenguaje.
Dada la versatilidad del compilador de MASM32 se logra una mejor compilación del uso de pilas en lenguaje ensamblador y así poder ejecutarlo en la consola de la máquina.
30
