Capítulo 4 - Escribiendo un programa en lenguaje ensamblador

Aquí está, por fin, el programa de lenguaje ensamblador que le prometimos: un programa que puede digitar, ensamblar y ejecutar sin tener que depender de ningún comando del Lenguaje BASIC. Este programa fue escrito en un computador Atari 800 viejo y lleno de cicatrices de batalla, usando un antiguo cartucho Atari Assembler Editor. Pero el programa se ejecutará en cualquier computadora Atari y, como todos los programas de este libro, es totalmente compatible con los cartuchos Atari Assembler Editor y el nuevo y más rápido ensamblador MAC/65 fabricado por OSS (Optimized Systems Software Inc., de San José, California).


Con unas pequeñas pero criticas modificaciones, tales como eliminar los números de línea y cambiar en la línea 40 la directiva "*= $0600" por "org $0600", este programa, y todos los demás en este libro pueden ser convertidos para que funcionen con el cartucho Atari Macro Assembler y su editor de texto. Pero a menos que usted ya sea un programador de lenguaje ensamblador, recomiendo encarecidamente que digite, ensamble, depure y edite los programas de este libro usando un ensamblador similar al MAC/65 o al cartucho Atari Assembler Editor, que son los que fueron utilizados para escribir dichos programas.


Aquí está el programa con el que vamos a trabajar en este capítulo. Como puede ver, se trata de un programa muy simple para sumar 2 más 2. Echemos una mirada en detalle, y veamos cómo hace lo que se supone que tiene que hacer.


UN PROGRAMA DE SUMAS DE 8 BITS
(ADDNRS.SRC)


10 ;
20 ;ADDNRS.SRC
30 ;
40               *=$0600
50 ;
60               CLD
70 ADDNRS        CLC
80               LDA #2
90               ADC #2
100              STA $CB
110              RTS
120              .END

https://www.atariware.cl/archivos/atariroots/ar14.jpg
Captura de pantalla de ADDNRS.SRC

Mire de cerca este programa y verá que los números que serán sumados, 2 y 2, están en la línea 80 y 90. Luego de que el programa realiza la suma, almacena el resultado del cálculo en la dirección de memoria $CB (o 203 en decimal). Eso pasa en la línea 100. Algunas instrucciones del programa pueden parecer conocidas; hemos visto la mayoría de ellas en los capítulos anteriores. Sin embargo, hay algunos elementos en el programa que se ven aquí por primera vez. Estos incluyen los puntos y comas en las primeras líneas del programa, la directiva "*=" en la línea 40, y la directiva ".END" en la línea 120.


Espaciamiento


Como se puede ver más claramente en el "diagrama ampliado" que sigue, el listado del código fuente del programa se divide en cuatro campos o columnas. Si cada campo tuviera un encabezado, y si el listado del programa no estuviera todo apretujado, esto es lo que se vería:


Un programa de sumas de 8 bits (ADDNRS.SRC)
(Listado columna a columna)
NOMBRE DE CAMPONUMERO DE LINEAETIQUETAOP CODEOPERANDOCOMENTARIO
10;
20;ADDNRS.SRC
30;
40 *=$0600
50;
60ADDNRSCLD
70 CLC
80 LDA#2
90 ADC#2
0100 STA$CB
0110 RTS
0120 .END

Sólo un ejemplo


El listado anterior es tan sólo una ilustración de cómo se vería el listado de un código fuente si sus cuatro campos (números de línea, etiquetas, op codes y comentarios) estuvieran claramente separados por columnas. En realidad, nadie escribe listados de código fuente de esta manera.


Cuando se escribe un listado de código fuente usando el MAC/65 o el cartucho Atari Assembler Editor, la forma habitual de hacerlo es digitando sus campos en un formato que es más bien hacinado: tan apretujado que las columnas no están alineadas para nada. Sin embargo, una vez que llegue a tener un poco de práctica en la escritura de código de esta manera, verá que se convierte en algo natural.


Estas son las reglas:


Los números de línea


Cuando se escribe un listado de código fuente mediante MAC/65 o el cartucho Atari Assembler Editor, a cada sentencia, o línea, se le debe asignar un número de línea. Los números de línea del programa se escriben a la izquierda, tal como en los programas en BASIC. Los números de línea no son realmente necesarios en los programas en lenguaje ensamblador, y algunos ensambladores no los requieren. El paquete Atari Macro Assembler y Atari program-Text Editor, por ejemplo, no requiere el uso de los números de línea y no ensamblará un programa que los incluya. Pero MAC/65 y el cartucho Atari Assembler Editor usan números de línea, por lo que también los usaremos, al menos por ahora.
Los números de línea en la primera columna de nuestro programa de sumas aumentan en incrementos de 10, al igual que los números en un programa típico de BASIC. No tienen que ser escritos de esa manera, pero por lo general es así, como es el caso de BASIC. Los números de línea pueden ir de 0 a 65535.


Etiquetas


Las etiquetas, si se utilizan, ocupan el segundo campo en las sentencias del lenguaje ensamblador. Se debe dejar exactamente un espacio, no dos, entre un número de línea y una etiqueta. Si escribe una etiqueta dos o más espacios después de un número de línea, o si se utiliza el tabulador para llegar al campo etiqueta, su programa no funcionará. En programas de lenguaje ensamblador, las etiquetas se utilizan para identificar las primeras líneas de las rutinas y subrutinas. Nuestro programa para sumar 2 y 2, por ejemplo, tiene la etiqueta ADDNRS en la línea 60.


Dado que nuestro programa tiene una etiqueta, este podría ser utilizado como una subrutina en un programa más largo, y se podría acceder fácilmente por medio de su etiqueta. Para invocarla se pueden usar varios tipos de instrucciones en lenguaje ensamblador. Por ejemplo, JSR ADDNRS (Salte a la subrutina que se encuentra en la etiqueta ADDNRS), BCS ADDNRS (Salte a la etiqueta ADDNRS cuando se desactive la bandera de acarreo), o JMP ADDNRS (saltar a la etiqueta ADDNRS). En el primer ejemplo, ADDNRS terminaría con la instrucción RTS (retorno de la subrutina) en la línea 100. RTS realiza el mismo tipo de trabajo en lenguaje ensamblador que la instrucción RETURN realiza en BASIC: señaliza el final de una subrutina, y el control vuelve de nuevo al cuerpo principal del programa. En los últimos ejemplos, se podría usar una segunda instrucción de salto en lugar de RTS para transferir el control.


Hablaremos de saltos, instrucciones de ramificación y subrutinas en mayor detalle en capítulos posteriores. Por ahora, lo más importante que debe recordar es que cuando se escribe un listado de código fuente en un ensamblador MAC/65 o un cartucho Atari Assembler Editor, se debe usar uno y sólo un espacio para separar cada etiqueta de su número de línea. El largo de una etiqueta puede ser desde un carácter hasta el largo que permita la sentencia (106 caracteres menos la cantidad de caracteres usados en el número de línea de la instrucción). La mayoría de los programadores usan etiquetas de entre tres y seis caracteres de longitud.


Mnemónicos de Código de Operación


Un Mnemónico de Código de Operación (u "op code") es sólo un nombre bonito para referirse a las instrucciones en lenguaje ensamblador. Hay 56 "op codes" en el conjunto de instrucciones del 6502, y son los únicos que pueden ser utilizados en las instrucciones del lenguaje ensamblador de Atari. "Op codes" tales como CLC, CLD, LDA, ADC, STA y RTS se escriben en el campo "op code" de los listados de código fuente de lenguaje ensamblador. Cuando se escribe un programa usando MAC/65 o el Atari Assembler Editor, cada "op code" que utilice debe comenzar con al menos dos espacios después del número de línea, o un espacio después de una etiqueta. Un "op code" colocado en el campo equivocado no se marcará como un error al escribir su programa, pero se marcará como un error cuando sea ensamblado.


El campo "op code" en un listado de código fuente se usa también para directivas y "pseudo ops", palabras y símbolos que se introducen en un programa como mnemotécnicos, pero que no son en realidad miembros del conjunto de instrucciones del 6502. El asterisco en la línea 40 de nuestro programa es una directiva, y la orden ".END" en la línea 120 es un "pseudo op". La directiva "*" se utiliza para decirle a su computador en qué lugar de la memoria se almacenará un programa después de haber sido ensamblado. La directiva ".END" se usa para decirle al ensamblador dónde debe dejar de ensamblar, y para finalizar un programa en lenguaje ensamblador.


Operandos


El campo "operando" en un programa de MAC/65 o Atari Assembler comienza a lo menos un espacio (o tabulación) después de un "op code". Los operandos se utilizan para ampliar los "op codes", haciendo que éstos sean instrucciones completas. Algunos "op codes", como CLC, CLD y RTS, no requieren operandos. Otros, como LDA, STA y ADC, requieren operandos. Vamos a entregar mucha más información acerca de los operandos más adelante.


Comentarios


Los comentarios en los programas en lenguaje ensamblador son como los comentarios en los programas BASIC: no tienen ningún efecto sobre el programa, sino que sirven para explicar los procedimientos de programación y proveer espacio para el descanso de los ojos en los listados de los programas. Hay dos maneras de escribir comentarios en los listados de código fuente escrito en el MAC/65 y el Atari Assembler Editor. Un método consiste en poner los comentarios en el campo de las etiquetas de un listado, precedido por punto y coma. El otro método consiste en ponerlos en el campo especial "Comentarios" que queda en cada línea de código a continuación de los campos de instrucción (los campos donde van los "op codes" y los operandos). Si utiliza el campo "Comentarios" al final de una línea y no tienen espacio allí para el comentario que desea escribir puede continuar sus comentarios en la siguiente línea simplemente digitando un espacio, un punto y coma, y el resto de sus comentarios.


Examinando el programa


Ahora que hemos visto nuestro programa de ejemplo campo por campo, vamos a examinarlo esta vez línea por línea.


Líneas 10 a 30 (Comentarios)


Las líneas de la 10 a la 30 corresponden a los comentarios. La línea 20 explica lo que hace el programa y las líneas 10 y 30 destacan con espacios en blanco las líneas explicativas. Es una buena práctica de programación el utilizar de manera abundante los comentarios en lenguaje ensamblador, así como en la mayoría de los otros lenguajes de programación, por lo que hemos utilizado varios comentarios en los programas de este libro.


Línea 40 (Directiva "*=")


Esta es la línea de origen de nuestro programa de ejemplo. Cada programa en lenguaje ensamblador debe empezar con una línea de origen. Como puede recordar del capítulo 1, lo primero que hace un computador cuando se ejecuta un programa en lenguaje de máquina es ir a una ubicación de memoria predeterminada y ver lo que se encuentra allí. Así que cuando usted escribe un programa en lenguaje ensamblador, lo primero que tiene que hacer es decirle a su equipo dónde en su memoria tiene que empezar a buscar su programa. Cuando el ensamblador encuentra una directiva de origen, asigna la dirección que figura en la directiva al contador de programa ("program counter") del procesador 6502 de su computadora. La primera instrucción del programa será cargada en esa posición de memoria, y el resto del programa seguirá la secuencia.


La directiva de origen parece una línea sencilla de escribir, pero decidir qué número se debe poner en esta línea puede ser un trabajo muy difícil, especialmente para los programadores principiantes en lenguaje ensamblador. Hay muchos bloques de memoria en su computador que no se pueden utilizar para programas en lenguaje ensamblador, porque están reservados para otros usos (por ejemplo, para almacenar el sistema operativo de su computador, el sistema operativo de disco, el intérprete BASIC, etc.). Incluso el ensamblador que usará para escribir este programa ocupa un bloque de espacio de memoria que es territorio prohibido para usted, al menos hasta que se familiarice con ciertos puntos de referencia que puede utilizar para encontrar su camino a través de la selva de la memoria de su computador.


Mientras tanto, sucede que existe un pequeño bloque de memoria que está reservado, en circunstancias normales, sólo para el tipo de programas cortos en lenguaje ensamblador escritos por el usuario, como los que vamos a estar usando en los siguientes capítulos. El bloque de memoria se llama "Página 6", ya que va desde la dirección de memoria $0600 a $06FF (1536 a 1791 en decimal). "Página 6" tiene sólo 256 bytes de longitud, pero ese espacio es más que suficiente para el programa que vamos a ver en este capítulo, y para los otros programas que usaremos en los próximos capítulos. Más adelante, como sus programas se harán cada vez más largos, aprenderá a pasar a bloques de memoria más grandes. La línea 40 en nuestro programa de sumas le dice a su computador que el programa que va a escribir comenzará en la dirección de memoria $0600 (1536 en decimal).


Línea 50 (Línea en blanco)


Esta línea de "Comentario" sólo sirve para separar la línea de origen de las otras líneas de nuestro programa. El espacio en blanco se ve bien, ¿no?


Línea 60 (Etiqueta: ADDNRS, Mnemotécnico: "Desactivar modo Decimal")
ADDNRS CLD


ADDNRS: Hemos utilizado el campo Etiqueta en esta línea para llamar a nuestro programa ADDNRS. Así que si decide usar nuestro programa como una rutina o una subrutina en un programa más grande, ya tendrá un nombre. Entonces, podremos direccionarla por su nombre, si lo deseamos, en lugar de su ubicación en memoria. Por lo general, es una buena práctica de programación el ponerle etiquetas a las rutinas y subrutinas importantes. Una etiqueta no sólo hace una rutina más fácil de localizar y utilizar, sino que también sirve como un recordatorio de lo que hace la rutina (o, hasta que el programa sea depurado, lo que se supone que tiene que hacer).


CLD: En este programa usamos números binarios simples, y no números en código binario decimal (BCD). Así que en esta línea vamos a desactivar la bandera de modo decimal del registro de estado del procesador 6502. La bandera decimal no necesita ser desactivada antes de cada operación aritmética en un programa, pero es una buena idea desactivarla antes de la primera suma o resta de un programa, ya que pueden haber sido activados en el transcurso de un programa anterior.


Línea 70 ("Desactivar la bandera de Acarreo")
CLC


La Bandera de Acarreo del Registro de Estado se ve afectada por tantos tipos de operaciones que se considera una buena práctica de programación el limpiar (desactivar) esta bandera antes de cada suma. Requiere sólo la mitad de una millonésima de segundo, y sólo un byte de memoria RAM. En comparación con el tiempo y la energía que la depuración nos pueda costar, es una ganga.


Línea 80 (“Cargar el Acumulador con el número 2")
LDA #2


Esta es una instrucción muy sencilla. El primer paso en una suma siempre es cargar el acumulador con uno de los números que se va a sumar. El símbolo "#" delante del número 2 significa que es un número literal, no una dirección. Si la instrucción fuese "LDA 2", entonces el acumulador se cargaría con el contenido de la dirección de memoria 0002, y no el número 2.


Línea 90 ("Sume, con acarreo, el numero 2 al contenido del Acumulador")
ADC #2


Esta es también una instrucción directa. "ADC #2" significa que el número literal 2 se añadirá al número que está en el Acumulador (En este caso, otro 2). Como hemos mencionado, no hay una instrucción en lenguaje ensamblador del 6502 que signifique "sumar sin acarreo". Así que la única manera de que una adición se pueda realizar sin acarreo es limpiando la Bandera de Acarreo del Registro de Estado y luego realizando una "suma con acarreo".


Línea 100 ("Almacene el contenido del Acumulador en la dirección de memoria $CB")
STA $CB


Esta línea completa nuestra suma. Almacena el contenido del Acumulador en la dirección de memoria $CB (decimal 203). Tenga en cuenta que el símbolo "#" no se utiliza antes del operando (CB) en esta instrucción, ya que el operando en este caso es una dirección de memoria, y no un número literal.


Línea 110 ("Retorno desde la subrutina")
RTS


Si el mnemotécnico RTS se utiliza al final de una subrutina, funciona de la misma manera que la instrucción RETURN en BASIC: termina la subrutina y vuelve al cuerpo principal de un programa, comenzando por la línea siguiente a la línea en que aparece la instrucción RTS. Pero si se utiliza RTS al final de la parte principal de un programa, tal como en nuestro ejemplo, tiene una función diferente. En este caso, entonces, en lugar de pasar el control del programa a una línea diferente, termina todo el programa y devuelve el control del computador al dispositivo de entrada que estaba en control antes de que comenzara el programa (Por lo general un cartucho, un sistema operativo, un editor de pantalla de teclado, o un monitor de lenguaje de máquina).


Línea 120
Directiva. END


Así como la Directiva "*=" comienza un programa de lenguaje ensamblador, la Directiva ".END" le pone fin al programa. La Directiva. END indica al ensamblador detener el ensamblaje, y eso es exactamente lo que el ensamblador hace, incluso si hay más código fuente después de la directiva. END. La Directiva. END por lo tanto puede ser utilizada como una poderosa herramienta de depuración. Usted puede ponerla donde desee en un programa que se está depurando, y ahí es donde el ensamblador siempre detendrá el ensamblado, hasta que usted elimine la Directiva ".END". Cuando haya terminado de depurar su programa puede utilizar la Directiva. END para que la rutina llegue ordenadamente a su fin. Antes de que pueda hacer eso, por supuesto, deberá quitar todas las directivas. END que aún queden por ahí, si es que quiere obtener su programa final completamente ensamblado. Cuando la depuración está completa y el programa está terminado, debe contener sólo una directiva. END, y ésta debe ir donde pertenece: al final de su programa.


Ensamblado de un Programa en Lenguaje Ensamblador


OK. ¿Está listo para escribir y ejecutar su primer programa en lenguaje ensamblador? Bien. Entonces, siéntese frente a su computadora, encienda su unidad de disco y el monitor de video, y ejecute su ensamblador (si está en disco), o inserte el cartucho de ensamblador (si este es el tipo de ensamblador que tiene) en la ranura de cartuchos en su Atari. Si estás usando el MAC/65 o un cartucho Atari Assembler Editor, su ensamblador estará listo para ser usado cuando la palabra "EDIT" aparezca en su monitor de video. Este mensaje es el equivalente en lenguaje ensamblador al "READY" del BASIC. Si esto no sucede, entonces compruebe todas las conexiones de los componentes del sistema y repita la puesta en marcha. Mientras no obtenga el mensaje "EDIT" del sistema, no se puede programar nada en lenguaje ensamblador.
Cuando tenga el ensamblador en marcha puede poner un disco vacío y formateado en su unidad de disco. Este disco debe tener un conjunto de archivos de DOS grabados en él para poder arrancar automáticamente sin necesidad de un disco de inicio al encender su computador. Si graba todos los programas de este libro en su disco de datos, aun así tendrá espacio para los archivos de DOS, los que le ahorrarán tiempo.


Digitando el Programa


Cuando el mensaje "EDIT" aparece en su pantalla, puede comenzar a digitar en su computador el programa de sumas (la versión código fuente) que viene al comienzo de este capítulo. A medida que digite el programa, tenga mucho cuidado con el espaciado que utiliza. MAC/65 y el cartucho Atari Assembler Editor son un poco quisquillosos con respecto al espaciado. En las líneas que tienen un punto y coma, recuerde que sólo debe haber un espacio entre el número de línea y el punto y coma. En la línea 40, sin embargo, debe haber al menos dos espacios entre el número de línea y el asterisco, ya que "*" es una directiva, y las directivas aparecen en el campo "op code" de los programas de MAC/65 y de Atari Assembler Editor.


En la línea 60, debe haber un espacio entre el número de línea y la etiqueta "ADDNRS", y un espacio entre "ADDNRS" y el mnemotécnico "CLD". En las líneas de la 70 a la 110 debe haber a lo menos dos espacios entre cada número de línea y el "op code" que viene a continuación. Y en la línea 120 debe haber al menos dos espacios entre el número de línea y la directiva ".END". Si comete un error al escribir una línea, puede retroceder y corregir, usando las teclas de control del cursor (flechas) de su teclado.


Listando su programa


Muy bien. Después de que haya digitado el listado del Programa 1 en su computador, escriba la palabra LIST. Debería ver en la pantalla algo así como esto:


EDIT
LIST

10 ;
20 ;ADDNRS.SRC
30 ;
40 *=$0600
50 ;
60 ADDNRS CLD
70 CLC
80 LDA #2
90 ADC #2
0100 STA $CB
0110 RTS
0120 .END

EDIT

Ahora, si tiene una impresora, puede imprimir su programa en papel. Sólo tiene que escribir:


LIST #P:

Es bastante fácil, ¿verdad? ¡Ni bien lo escribe y ya está terminado! Ahora, si su listado se ve bien, puede guardar su programa en un disco. Sólo asegúrese de que un disco formateado (de preferencia uno virgen) está en nuestra unidad de disco y la luz de preparado (“ready”) está encendida.
A continuación, digite:


LIST #D:ADDNRS.SRC

Ahora debe encenderse la luz roja de arriba en la unidad de disco, y el disco en el que está guardando su programa debe empezar a girar. Cuando la luz ocupado (“busy”) de su unidad de disco se apague, su código fuente habrá sido grabado en el disco con el nombre de archivo #D:ADDNRS.SRC. Le recomendamos que guarde su código fuente ADDNRS.SRC en un lugar seguro, ya que trabajaremos con este programa en capítulos posteriores. Ahora, de hecho, puede usar ese mismo código fuente para ensamblar su programa. Para hacer esto, ponga su disco con el código fuente en su unidad de disco y su cartucho Assembler Editor en su computador, y escriba el comando ASM. Tan pronto como haya hecho esto, el computador presentará en pantalla lo siguiente:


EDIT
ASM
PAGE 1

10 ;
20 ;ADDNRS.SRC
30 ;
0000 40 *=$0600
50 ;
0600 D8 60 ADDNRS CLD
0601 18 70 CLC
0602 A902 80 LDA #2
0604 6902 90 ADC #2
0606 85CB 0100 STA $CB
0608 60 0110 TS
0609 0120 .END

*** ASSEMBLY ERRORS: 0 23202 BYTES FREE(1)
PAGE 2
SYMBOLS

0600 ADDNRS

EDIT

(1)Esto depende de la versión de DOS que usted tenga.


https://www.atariware.cl/archivos/atariroots/ar15.jpg
Captura de pantalla de ADDNRS.SRC ensamblado
con el Atari Assembler Editor

Si ha cometido algún error al digitar su programa, aquí es donde probablemente se enterará. Si el ensamblador encuentra un error en una línea, sonará un pitido y mostrará un mensaje de error. Es posible que no sea capaz de detectar todos los errores que usted cometa, pero cuando detecte uno, imprimirá un número de error en la pantalla (de manera similar a como lo hace el intérprete BASIC). Puede averiguar lo que significa ese número consultando el manual de usuario del MAC/65 o del Atari Assembler Editor. Si el ensamblador encuentra algún error en su programa puede digitar LIST, volver atrás y corregir. Entonces puede volver a escribir ASM e intentar una vez más ensamblar su programa. ¡Una vez que el listado de su código objeto se haya desplegado en la pantalla sin ningún mensaje de error, sabrá que su programa ha sido ensamblado correctamente y que acaba de escribir y ensamblar su primer programa en lenguaje ensamblador!


Una diferencia entre ensambladores


Hemos llegado a una diferencia importante entre el cartucho Atari Assembler Editor y el ensamblador MAC/65. Cuando ensamblamos el código fuente del programa usando el cartucho Atari Assembler Editor, el código objeto generado por el proceso de ensamblaje se almacena automáticamente en la memoria de su computador. Sin embargo, cuando ensamblamos un programa mediante el ensamblador MAC/65, el código objeto no se almacena automáticamente en la memoria a menos que utilice una directiva especial. Esta directiva es ".OPT" (por "OPTion (opción)" ). La directiva de opción se utiliza de la siguiente manera:


05 .OPT OBJ

Si tiene un ensamblador MAC/65, puede insertar esta línea en su programa ADDNRS.SRC, y el programa se almacenará automáticamente en la memoria RAM a medida que sea ensamblado.


¿Qué viene a continuación?


Una vez que haya almacenado un programa en la memoria RAM, puede hacer lo que quiera con él, como por ejemplo: ejecutarlo, imprimirlo en papel, guardarlo en disco, o guardar en la memoria de su computador. Sin embargo, antes de hacer cualquiera de estas cosas, es una buena idea echar una mirada más de cerca al programa ADDNRS, al listado de código objeto del programa en su forma final ensamblada. En la columna 1 del listado de código objeto, verá las direcciones de memoria en las que su suma se almacenará luego de haber sido cargada en la memoria de su computador. La columna 2 es el listado de código objeto real de su programa. Es esta columna la que le mostrará, en notación hexadecimal, la versión real en código máquina de su programa. Este es el significado de los números en la columna 2:


CODIGO FUENTECODIGO MAQUINASIGNIFICADO
CLDD8Desactivar la bandera modo decimal del registro de estado
CLC18Desactivar la bandera de acarreo del registro de estado
LDA #2A9 02Carga el Acumulador con el número 2
ADC #269 02Sumar 2, con acarreo
STA $CB85 CBAlmacenar el resultado en la dirección de memoria CB (203 en decimal)
RTS60Retorno de subrutina

Ahora bien, si lo desea, puede imprimir su listado ensamblado en papel. Simplemente digite ASM, #P: y obtendrá un listado impreso de su programa ensamblado.


Guardando su programa


Ahora usted ha escrito, ensamblado e impreso su primer programa en lenguaje ensamblador. Y eso significa que estamos casi listos para poner fin a esta sesión de programación. Pero antes de apagar el equipo, no sería una mala idea guardar el código objeto de nuestro programa en un disco. Así que eso haremos ahora.


¿"LIST" o "SAVE"?


Unos párrafos más atrás usted guardó el código fuente de su programa de sumas con el comando "LIST". Pero para guardar el código objeto de un programa en lenguaje ensamblador, hay dos comandos. Uno de ellos es SAVE. El otro es BSAVE. Si está usando el ensamblador MAC/65, el comando que se debe usar para guardar la versión código objeto del programa ADDNRS es BSAVE. Sin embargo, si está utilizando el cartucho Atari Assembler Editor, el comando a utilizar es SAVE.


Guardando el código objeto de un programa


Sin embargo, los comandos SAVE y BSAVE se utilizan de la misma forma. He aquí cómo se hace: Primero, escriba el comando ASM, y su computador ensamblará el código fuente de su programa de sumas. (Si ya ha hecho esto antes, no hay problema en hacerlo de nuevo). A continuación, mire la columna 1 del listado de código objeto en la pantalla y observe las direcciones de memoria en las que se ha ensamblado su programa. El programa debe comenzar en la dirección de memoria $0600 y debe terminar en la dirección de memoria $0609. Así que esta es la línea que se debe digitar si usted tiene un ensamblador MAC/65.

BSAVE #D:ADDNRS.OBJ<0600,0609

Y esta es la línea que se debe digitar si usted tiene un cartucho Atari Assembler Editor:


SAVE #D:ADDNRS.OBJ<0600,0609

Tan pronto como digite esa línea y presione la tecla RETURN, la luz ocupado (“busy”) en su unidad de disco debería encenderse, y su disco debería comenzar a girar. Cuando la luz ocupado (“busy”) se apague y su unidad de disco se detenga, el listado de código objeto de nuestro programa de sumas habrá sido ser almacenado de forma segura en el disco con el nombre de archivo #D:ADDNRS.OBJ.


¿Funcionó?


Ahora vamos a comprobar si todo esto de hacer LIST y SAVE funcionó. Primero digite el comando NEW y luego presione la tecla RETURN para borrar la memoria de su computador. A continuación, escriba "ENTER #D:ADDNRS.SRC". Su unidad de disco debe comenzar a girar, y el mensaje EDIT debe aparecer en su pantalla. Ahora, si escribe el comando LIST, el listado del código fuente del programa ADDNRS debería aparecer en nuestra pantalla de video. Ahora, si el ensamblador es un MAC/65, escriba la línea "BLOAD #D:ADDNRS.OBJ", y presione la tecla RETURN. Si tienen un cartucho Atari Assembler Editor, digite "LOAD #D:ADDNRS.OBJ". Su unidad de disco ahora debería cargar el código objeto del programa ADDNRS en el equipo, y la palabra EDIT debería aparecer una vez más. Entonces, si digita el comando ASM de nuevo, el listado en código ensamblador del programa ADDNRS debería aparecer en su pantalla.


Avanzando


Usted ha logrado mucho en este capítulo. Ha escrito y ensamblado su primer programa en lenguaje ensamblador y, con suerte, tendrá una comprensión bastante buena de cómo esto se hace. Ha guardado su listado de código fuente y su listado de código ensamblador en un disco. Si tiene una impresora, también habrá impreso listados en papel. Y ahora, en el capítulo 5, vas a aprender a ejecutar un programa en lenguaje ensamblador.