Capítulo 5 - Ejecución de un Programa en Lenguaje Ensamblador

Existen varias formas de ejecutar un programa en lenguaje de máquina en un computador Atari. Por ejemplo:


  • Usando un comando especial de depuración (el comando "G") incluido tanto en el Ensamblador MAC/65 como en el cartucho Atari Assembler Editor.
  • Ejecutando el programa por medio del sistema operativo de disco de Atari (DOS) o el sistema operativo OS/A+ (Si tiene el ensamblador MAC/65).
  • Usando el utilitario AUTORUN.SYS del Atari DOS (o el programa STARTUP.EXC si es que está utilizando el sistema operativo OS/A+).
  • Invocando su programa en lenguaje de máquina desde un programa BASIC.

En este capítulo, vamos a cubrir los tres primeros métodos de ejecución de programas en lenguaje de máquina. La cuarta técnica, invocar al programa en lenguaje de máquina desde un programa BASIC, será tratada en el Capítulo 8. Primero vamos a discutir la técnica para ejecutar un programa con el comando "G" que ofrecen tanto el ensamblador MAC/65 como el cartucho Atari Assembler Editor.


El monitor incluido en su ensamblador


Para utilizar el comando "G", necesitará de la ayuda de una herramienta práctica que viene gratis en el ensamblador MAC/65 y en el cartucho Atari Assembler Editor. A esta herramienta se le denomina utilitario de depuración. Si acaba de terminar de leer el capítulo 4 y todavía tiene su computador encendido, puede empezar a usar la herramienta de depuración de su ensamblador en sólo unos instantes, tan pronto como los lectores que apagan sus computadores entre cada capítulo tengan la oportunidad de prenderlos nuevamente.


Si apagó su computador al final del capítulo 4, por favor, enciéndalo nuevamente. Necesitará su disco de datos y su ensamblador funcionando. Cuando el mensaje EDIT aparezca en la pantalla, cargue en la memoria de su computador el código fuente del programa que escribió en el capítulo 4. Primero escriba la palabra "NEW", un buen hábito para cuando se quiera cargar un programa, por si acaso hay otro programa en la memoria. Luego, escriba


ENTER #D:ADDNRS.SRC


Tal como lo hizo cuando cargó el programa ADDNRS.SRC al final del Capítulo 4. Cuando su unidad de disco deje de girar, puede comprobar si el programa se ha cargado correctamente simplemente escribiendo el siguiente comando:


LIST


Entonces debería poder ver el programa en su pantalla. Ahora vamos a ensamblar el programa. En realidad, si usted hizo los ejercicios del Capítulo 4, nuestro programa ADDNRS ya estará ensamblado y almacenado en su disco de datos. Pero el programa es tan corto que le tomara más tiempo cargar el código objeto desde el disco que ensamblarlo nuevamente. Así que eso haremos. Si está usando el ensamblador MAC/65, eche un vistazo al listado del código fuente de su programa y asegúrese que contenga la siguiente línea

05 .OPT OBJ

De modo que sea cargado en la memoria del computador a medida que sea ensamblado. ¡Si está usando un cartucho Atari Assembler Editor, la línea 5 no debe estar en su programa! ¡La directiva. OPT no tiene ningún significado para el cartucho Atari Assembler Editor, y será marcada como un error!


Una vez que la línea 5 esté en su programa (o no lo esté, dependiendo del tipo de ensamblador que tenga), puede ensamblar el programa ADDNRS. Para ello, basta con teclear:


ASM


Su ensamblador le presentará el listado correspondiente al código objeto de su programa ADDNRS.


Luego puede utilizar la herramienta de depuración incluida en el MAC/65 o ensamblador Atari para depurar el programa y guardarlo en el disco en su forma final. Las utilidades de depuración del ensamblador MAC/65 y del Atari Assembler Editor son bastante similares. Pero tienen algunas diferencias.


Utilizando el depurador del MAC/65


El depurador integrado en el ensamblador MAC/65 se llama BUG/65. Para usarlo primero debe asegurarse de que su código fuente ADDNRS ha sido ensamblado correctamente usando la directiva ".OPT OBJ". Luego, mientras el ensamblador se encuentra en el modo EDIT, escriba el comando "CP". Esto le llevará de vuelta al sistema operativo OS/A+ de su ensamblador. Ahora, en respuesta al mensaje "D1" del sistema operativo OS/A+, teclee "BUG65". La unidad de disco debe empezar a girar, y cuando se detenga, la pantalla con borde amarillo del BUG/65 deberá aparecer en el monitor de su computador.


Utilizando el depurador del ensamblador de Atari


Si está utilizando un cartucho Atari Assembler Editor, el poner su ensamblador en modo "DEBUG (depuración)" es aún más fácil. Sólo tiene que teclear


BUG


https://www.atariware.cl/archivos/atariroots/ar16.jpg
Entrando al Modo de Depuración

– (y no DEBUG), seguido por un retorno de carro. Esto le mostrará el siguiente mensaje en la pantalla:


DEBUG


https://www.atariware.cl/archivos/atariroots/ar17.jpg
Modo de depuración del Atari Assembler Editor

– y cuando este comando aparezca en su pantalla, podrá depurar sus programas en lenguaje ensamblador usando una serie completa de comandos.


En este capítulo trataremos sólo algunas de las muchas capacidades del paquete de depuración de su ensamblador. El depurador de su ensamblador es un paquete de software muy especial. Con él, puede hacer PEEK a los registros de memoria de su computador, y desplegar de diferentes formas el contenido de estos registros. Incluso puede ejecutar sus programas utilizando el depurador de su ensamblador, el cual puede advertirle de la presencia de muchos tipos de errores de programación mientras el programa se está ejecutando o incluso después de que éste se haya ejecutado.


Uso del paquete de depuración


Ahora vamos a mostrar cómo el monitor integrado de su ensamblador puede ayudarle a examinar el contenido de la memoria RAM de su Atari. Luego tendrá la oportunidad de ejecutar un programa en lenguaje de máquina usando el monitor que viene integrado en su ensamblador.


Desplegando el contenido de las Posiciones de Memoria


Como hemos señalado anteriormente, todas las características del monitor que viene integrado en su ensamblador pueden ser invocadas cuando éste se encuentra en modo DEBUG (depuración). Por ejemplo, cuando está en modo de depuración, puede echar un vistazo al contenido de las posiciones de memoria, usando la instrucción "D", que significa "mostrar memoria (Display memory)". El comando "D" es similar al comando PEEK de BASIC. Mediante el uso del comando "D" puede echar un vistazo a los registros de memoria de su Atari y ver su contenido. Para utilizar el comando "D", solo tiene que indicarle a su ensamblador las posiciones de memoria que desea mirar. Si escribe una "D" seguido de una dirección de memoria (expresado en número hexadecimal, por supuesto), obtendrá un listado en pantalla de la posición solicitada y las siete posiciones que le siguen. Si ya ensambló el código fuente de su programa ADDNRS, puede ver ahora mismo cómo funciona el "comando D" de su monitor. Simplemente escriba


D600


– y verá en la pantalla algo así:

0600 D8 18 A9 02 69 02 85 CB

(Si tiene el ensamblador MAC/65, verá algunos caracteres más después de las letras "CB". No les preste atención, son solo caracteres que en determinadas circunstancias representan los números de esta línea, pero que no significan nada en el contexto de lo que estamos haciendo ahora). Al revisar cualquier listado de código objeto que hemos creado en otros ejercicios, verá que el resto de la línea no es sino un listado de código de máquina correspondiente a los primeros ocho bytes de su programa ADDNRS.OBJ. También puede utilizar el "comando D" de su monitor para ver más de ocho posiciones consecutivas de la memoria de su computador. Sólo tiene que escribir dos direcciones después de la "D", utilizando el formato

D5000 500F

– en el caso del ensamblador MAC/65, y el formato

D5000, 500F

– en el caso del cartucho Atari Assembler Editor..


Entonces el depurador de su ensamblador le mostrará un listado con el contenido de todos los registros que van desde la primera dirección hasta segunda dirección. Para ver cómo funciona el comando "D" cuando se utiliza el segundo parámetro opcional, escriba:

D0600 0608

(o D0600,0608 si tiene el ensamblador Atari)


Obtendrá un listado como el que sigue (con algunos símbolos extra añadidos si su ensamblador es un MAC/65):

0600 D8 19 A9 69 02 85 CB
0608 60 00

Esto corresponde, por supuesto, al listado desensamblado de su programa de sumas, completo, hasta el último mnemónico (la instrucción RTS).


El comando 'L' del Atari Assembler Editor


El Atari Assembler Editor también incluye el comando "L" (Listar memoria con desensamblado – List Memory with Disassembly). (El ensamblador MAC/65 también tiene un comando "L", pero es totalmente diferente. El comando "L" del MAC se utiliza para buscar cadenas de caracteres hexadecimales). Pero el comando "L" del ensamblador de Atari puede ser utilizado para mostrar listados desensamblados de programas en lenguaje de máquina. El comando "L" del Atari Assembler Editor es similar al comando "D", pero existen algunas diferencias. El comando "L" de Atari, tal como el comando "D", puede ser ejecutado usando una o dos direcciones. Cuando se utiliza solo una dirección, el comando "L" desplegará un listado con el contenido de 20 posiciones de memoria consecutivas en su computador (no el contenido de sólo ocho posiciones, como lo hace el comando "D").


Sin importar si se usa o no la segunda dirección opcional, el comando "L" desensamblará el código de máquina en las direcciones que se muestran por pantalla; al lado de cada número hexadecimal aparecerá la instrucción en lenguaje ensamblador a la que equivale el número, si es que existe. Para ver cómo funciona el comando "L", escriba lo siguiente en su ensamblador de Atari.


L0600,0608


Si intenta ingresar esa línea en el ensamblador MAC/65, solo obtendrá un pitido enojado y un mensaje que dice "COMMAND ERROR! (¡Error de comando!)". Pero si tiene un ensamblador Atari, esto es lo que verá:

0600 D8 CLD
0601 18 CLC
0602 A9 02 LDA #$02
0604 69 02 ADC #$02
0606 85 CB STA $CB
0608 60 RTS

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

Este es el listado del contenido real de las direcciones de memoria de la $0600 a la $0608 de su equipo, luego de que el código fuente ADDNRS.SRC haya sido ensamblado y almacenado en la RAM. Con sólo mirar el listado, podrá notar que su programa ha sido ensamblado y cargado en la memoria RAM correctamente, y que ahora está en la memoria RAM esperando a ser ejecutado. Hemos llegado al comando de depuración que se usa para ejecutar un programa, el comando "G" (de "Go" – Ejecutar).


Santa G


Afortunadamente, el comando "G" puede ser utilizado tanto en el ensamblador MAC/65 como en el cartucho Atari Assembler Editor. Mediante el uso del comando "G", le puede indicar a su computador que ejecute el código en lenguaje de máquina que comienza en cualquier posición de memoria que se especifique. Si tiene un cartucho de Atari Assembler Editor, verá que es muy fácil utilizar el comando "G". Cuando el ensamblador se encuentre en modo de depuración, teclee la letra G, seguido de la dirección de memoria en la que comienza el programa. Si está usando el Atari Assembler Editor, puede utilizar el comando "G" para ejecutar ahora mismo su programa ADDNRS. Sólo tiene que teclear

G0600

El programa se ejecutará.
Si tiene un ensamblador MAC/65, verá que el comando "G" es un poco más potente y que, en este caso, necesita de un parámetro adicional. Cuando utilice el comando "G" del MAC, puede (y en este caso debe) utilizar tanto una dirección de comienzo como una dirección de término (o "punto de ruptura") de la rutina que desea ejecutar. Y cuando digite el parámetro de punto de ruptura de su programa, deberá marcarlo con el prefijo "@". Por ejemplo, he aquí cómo se usa el comando "G" para ejecutar el programa ADDNRS utilizando el depurador MAC/65:

G 0600 @0608

En el manual del usuario del MAC/65 y del BUG/65 se muestran más formas de usar del comando "G".


Sin campanas ni silbatos


Si su programa ADDNRS se ejecuta sin errores por medio del uso del comando "G" del MAC/65 o del Atari Assembler, no verá mucha acción en la pantalla de su computador. El programa hará tranquilamente su trabajo, que es sumar 2 más 2, y a continuación, tan rápido como un guiño, le devolverá el control de su computador. En este punto, verá en la pantalla los registros internos de su Atari. Si tiene el Atari Assembler Editor, la pantalla se verá así:

A=1C X=00 Y=00 P=30 S=04

Si tiene el ensamblador MAC/65, la pantalla ser verá un poco más complicada:

A X Y SP NV_BDIZC PC INSTR
04 00 00 00 00100000 0608 RTS

Ambas pantallas cumplen la misma función: nos muestran que el programa terminó de ejecutarse y que ha dejado algunos valores en cinco de los registros del chip 6502: el acumulador, el registro X, el registro Y, el registro de estado del procesador, y el puntero de la pila. En la línea que muestra el depurador MAC/65 se ve la dirección que tenía el contador de programa (PC) cuando el programa llegó a su punto de interrupción. El último elemento en la línea (INSTR) nos muestra cual era la instrucción que estaba en esa dirección.


Toda esta información puede ser útil en algunas aplicaciones de depuración, ya que a veces es útil saber en qué condiciones ha quedado el chip 6502 después de que un programa se ha ejecutado. Pero esto no significa mucho para nosotros ahora, ya que nuestro programa ha finalizado su ejecución y realmente no nos importa lo que contienen los registros del 6502. Lo más importante para nosotros ahora es saber si nuestro programa hizo o no lo que tenía que hacer. La única manera de averiguarlo es mirando si el programa hizo lo que se le indicó, es decir, si sumó 2 más 2, y si almacenó el resultado del cálculo en la dirección de memoria $CB.


Mientras el ensamblador se encuentra en modo "depuración (debug)", puede hacer PEEK fácilmente en la dirección de memoria $CB y ver si se almacenó allí la suma de 2 más 2. Simplemente teclee:

DCB

Entonces debería ver una o dos líneas como estas en su pantalla (de nuevo, con algunas pequeñas y no muy significativas diferencias si nuestro ensamblador es el MAC/65):

00CB 04 00 00 00 00
00D0 00 79 00

¡Éxito! ¡El número 4, la suma de 2 más 2, está almacenado en la dirección de memoria $CB!


Guardando un Programa en Lenguaje de Máquina


En el capítulo 4, aprendió a guardar listados de código fuente y listados de código objeto de sus programas en lenguaje ensamblador. En el lenguaje ensamblador de Atari, los listados de código fuente se cargan en memoria con el comando ENTER, y se guardan en el disco utilizando el comando LIST. Si tiene el ensamblador MAC/65, también puede cargar el código fuente en la memoria usando el comando LOAD (cargar), y puede guardar en el disco sus listados de código fuente usando el comando SAVE (guardar). Cuando se usa el ensamblador MAC/65, se usa LIST y ENTER para guardar y cargar el código fuente de los programas sin "tokenizar" (abreviar), y se usa LOAD y SAVE para cargar y guardar el código fuente en forma abreviada o "tokenizada". Este es el mismo sistema utilizado en Atari BASIC para cargar y almacenar programas.


Si tiene un cartucho de Atari Assembler Editor, verá que los comandos LOAD y SAVE se utilizan con fines totalmente distintos. En los programas escritos con el Atari Assembler Editor, los comandos LOAD y SAVE están reservados para cargar y guardar código objeto, por lo que no se pueden usar para cargar y guardar listados de código fuente. Los listados de código objeto se cargan en memoria utilizando el comando LOAD (con el Atari Assembler) o BLOAD (con el MAC/65), y se guardan en disco utilizando los comandos SAVE (con el cartucho de Atari) o BSAVE (con el MAC/65). Los códigos fuente de los programas deben ser cargados en memoria y guardados en disco mientras el ensamblador está activo y en modo de edición. Pero los códigos objeto de los programas pueden ser cargados y guardados de dos maneras distintas.


Puede cargar y guardar el código objeto de los programas mientras el ensamblador esté activo y en modo de edición. También puede cargar y almacenar el código objeto de los programas usando el sistema operativo del disco OS/A+ o el de Atari. Para guardar el código objeto de un programa utilizando el menú del DOS de Atari, todo lo que tiene que hacer es seleccionar la opción de menú K, el comando "carga de binarios (Binary Load)".


Para guardar el código objeto de un programa con el sistema operativo OS/A+, el formato correcto es el siguiente:


[D1:]SAVE ADDNRS.OBJ 0600 0608


Sé que todo esto es un poco confuso, pero al menos tiene este capítulo para guiarse, y esto es mucho más de lo que había cuando yo estaba aprendiendo a programar en lenguaje ensamblador de Atari.


Escribiendo programas para que se ejecuten una vez que estos sean cargados


Puede utilizar tanto el menú de Atari DOS como el del sistema operativo OS/A+ para guardar los programas en lenguaje de máquina de manera que estos se ejecuten automáticamente en cuanto se hayan cargado en la memoria de su computador. Cuando se selecciona la opción "K" en el menú del Atari DOS, su equipo responde con este mensaje:


SAVE – GIVE FILE, START, END, INIT, RUN


https://www.atariware.cl/archivos/atariroots/ar18.jpg
Menú de Atari DOS 2.0

Si lo desea, puede responder a esta solicitud ingresando sólo dos direcciones: START y END. Pero el sistema también le permite utilizar dos direcciones más: INIT y RUN. Estas dos direcciones son parámetros opcionales. Cuando se guarda un programa sin utilizar estos parámetros, el programa guardado se cargará en memoria pero no se ejecutará después de haber sido leído del disco. Para ejecutar una programa que ha sido guardado sin usar los parámetros INIT o RUN, se debe usar un comando de ejecución especial: ya sea la opción M (RUN AT ADDRESS – Ejecutar en la dirección) del menú de DOS, o alguno de los comandos especiales (como el comando "G") que se encuentran disponibles en varios ensambladores, depuradores, y sistemas operativos.


Si lo desea, puede utilizar el DOS de Atari para guardar el código objeto de un programa de manera que se ejecute automáticamente cuando este se cargue en memoria. De hecho, si lo desea, puede incluso guardar el código objeto de un programa de manera que se ejecute tan pronto arranque ("boot") el disco en el que se encuentra almacenado. Para marcar un código objeto de un programa de manera que se ejecute automáticamente cuando se cargue en memoria, puede guardarlo desde el DOS usando el parámetro INIT, el parámetro RUN, o ambos. Los parámetros INIT y RUN hacen cosas distintas, por lo que no sorprende que sean utilizados para fines distintos.


Cuando se utiliza INIT, el programa empezará a ejecutarse en su dirección INIT tan pronto como esta dirección sea cargada en memoria. Cuando se utiliza el parámetro RUN, el programa empezará a ejecutarse en esa dirección, pero no hasta que el programa completo haya sido cargado en memoria. El parámetro INIT normalmente se usa para ejecutar rutinas dentro de un programa corto, mientras el programa se está cargando. Por ejemplo, convertir cadenas de texto de un tipo de código de caracteres a otro, de modo que todas las conversiones se hayan completado al momento en que el programa sea ejecutado. El parámetro RUN se utiliza para ejecutar un programa en su totalidad después de que éste se ha cargado en memoria.


Usando el Parámetro 'RUN'


Así es como se debe almacenar el programa ADDNRS.OBJ con el cartucho Atari Assembler Editor utilizando el parámetro RUN, pero sin el parámetro INIT:


ADDNRS.OBJ,0600,0608,,0600


Fíjese en las dos comas entre el número 0608 y 0600. Esto significa que la instrucción INIT se ha dejado en blanco, y por lo tanto no se utilizará. Si se hubiera utilizado, sería el tercer número escrito, justo entre las comas. En cambio, la línea se ha escrito usando este otro formato:


ADDNRS.OBJ,START,END,,RUN


Por lo tanto, el programa se ejecutará de forma automática, a partir de la dirección $0600 (la dirección indicada en el parámetro RUN), tan pronto como se cargue completamente en la memoria. Si ha guardado el programa con este formato, y luego se carga el programa en la memoria de su computador, comenzará la carga en la dirección $0600 y terminará la carga en la dirección $0608. Luego comenzará a ejecutarse en la dirección $0600.


Utilizando el parámetro 'INIT'


El parámetro "INIT" del comando Binary Load del Atari Assembler Editor puede utilizarse solo o con el parámetro "RUN". Puede utilizar el comando "INIT" tantas veces como desee en su programa, para cada parte de éste que se desee ejecutar, a medida que sea ensamblado. El comando "RUN" sólo puede utilizarse una vez: para ejecutar todo el programa. Las instrucciones detalladas del uso de los comandos RUN e INIT se encuentran en el Manual de Referencia de su Atari Disk Operating System II. Por ahora, todo lo que necesitamos saber es que se puede guardar el código objeto de sus programas de manera que empiecen a ejecutarse después de que sean cargados usando el parámetro opcional "RUN" del comando "Binary Load".


Ejecutando programas en Lenguaje de Máquina usando el OS/A+


El OS/A+ no ofrece ningún parámetro INIT o LOAD para ejecutar programas en lenguaje de máquina, ya que no requiere ninguno de éstos. Para ejecutar un programa en lenguaje de máquina usando el OS/A+, todo lo que tiene que hacer es usar el comando "RUN": Sólo responda al mensaje "D1:" del sistema escribiendo la palabra RUN, seguido por la dirección de inicio del programa que desea ejecutar. Por ejemplo:


[D1:]RUN 0600


Entonces se ejecutará el archivo binario almacenado en esa dirección.


Escritura de Programas con auto-arranque


¿Alguna vez ha querido escribir un programa que arranque ("boot") por sí solo y a continuación se ejecute de manera automática, tan pronto como usted encienda su computador? ¡Bueno, puede hacerlo fácilmente, si sabe cómo usar el lenguaje Assembler! Todo lo que tiene que hacer es guardar el programa usando el utilitario AUTORUN.SYS que viene integrado en el DOS de Atari (o el utilitario STARTUP.EXC proporcionado por OS/A+, que vamos a discutir en un momento). Utilice cualquiera de estos utilitarios, y su programa se ejecutará automáticamente cada vez que arranque el disco en el que fue guardado. ¡De la misma manera que el software profesional!


Dos maneras de hacerlo


Hay varias maneras de utilizar el AUTORUN.SYS de Atari. Una forma es simplemente guardando su programa usando el nombre de archivo AUTORUN.SYS y el parámetro INIT, RUN o ambos. Otra manera es tomar un programa que haya guardado anteriormente como programa de ejecución automática y simplemente cambiar su nombre a AUTORUN.SYS. A continuación se explicará cómo se debe cambiar el nombre de un archivo a AUTORUN.SYS usando el cartucho Atari Assembler Editor. En primer lugar, asegúrese de que el programa que desea convertir ya sea un programa autoejecutable. En otras palabras, asegúrese de que haya sido guardado utilizando el parámetro RUN, INIT, o ambos. Luego invoque al menú de DOS y seleccione la opción "E" – "RENAME FILE (Cambiar nombre de archivo)". A continuación verá este mensaje:


RENAME – GIVE OLD NAME, NEW


En respuesta a este mensaje del sistema, escriba:


ADDNRS.OBJ,AUTORUN.SYS


¡Eso es todo lo que tiene que hacer! A partir de ahora, cada vez que arranque del disco en el que está el Programa 1, éste se ejecutará de manera automática (Si lo desea, puede usar el monitor del cartucho Atari Assembler Editor, para asegurarse de que es verdad).


Usando el utilitario STARTUP.EXC del OS/A+


El utilitario STARTUP.EXC proporcionado por el OS/A+ es similar al AUTORUN.SYS ofrecido por DOS de Atari. Para utilizar el utilitario STARTUP.EXC, sólo arranque el OS/A+ y luego cambie el disco maestro del OS/A+ por el disco de datos en el que está almacenado el código objeto de su programa ADDNRS. Cuando el disco de datos esté en su lugar, responda al mensaje "D1:" del sistema operativo OS/A+ escribiendo lo siguiente:


TYPE E: D1:STARTUP.EXC


Esta es la línea que verá luego en su pantalla:


D1:TYPE E: D1:STARTUP.EXC


Cuando escriba esta línea, asegúrese de usar el mismo espaciado que se utilizó en los ejemplos. En particular, asegúrese de que hay un espacio entre "E:" y "D1: STARTUP.EXC". OS/A+, al igual que el ensamblador MAC y el Atari Assembler Editor, es bastante quisquilloso con el espaciado. Cuando esté seguro de que escribió la línea correctamente, presione la tecla RETURN y verá que la pantalla del computador se quedará en blanco por un momento. Cuando las luces se enciendan de nuevo, verá la pantalla en blanco con un cursor en la esquina superior izquierda. Cuando la pantalla en blanco y el cursor aparezcan, simplemente escriba la palabra "LOAD", seguido del nombre del archivo que desea convertir en un archivo de arranque ("boot") automático.


Por ejemplo:


LOAD ADDNRS.OBJ


A continuación, escriba la palabra "RUN", seguido de la dirección (en hexadecimal) en la que se encuentra la primera instrucción de su programa. Por ejemplo:


RUN 0600


En este punto, estas dos líneas serán lo único que verá en su pantalla:


LOAD ADDNRS.OBJ
RUN 0600


Ahora presione la tecla RETURN, seguido por [CONTROL] 3 (Que se digita, por supuesto, pulsando la tecla CONTROL y la tecla "3" al mismo tiempo). Cuando haya hecho esto, su disco de datos comenzará a girar. Cuando se detenga, el programa ADDNRS.OBJ habrá sido almacenado en su disco como un archivo de arranque ("boot") automático. Cuando haya terminado de crear el archivo STARTUP.EXC, puede comprobar si está realmente en el disco escribiendo el comando "DIR" para obtener el directorio de disco. Luego, si el archivo STARTUP.EXC está allí, puede comprobar si funciona apagando el computador y luego encendiéndolo. Cuando el equipo esté encendido, cargue el depurador en la memoria escribiendo el comando BUG65. Luego puede utilizar el comando "D" del depurador para comprobar los registros de memoria del $600 al $608, para ver si su programa se ha cargado, y el registro de memoria $CB, para ver si se ha ejecutado correctamente.


Invocando programas en lenguaje de máquina desde el BASIC


También puede ejecutar programas en lenguaje de máquina, llamándolos desde programas BASIC. Pero es un proceso complejo, que requiere la comprensión de algunas técnicas de programación bastante sofisticadas. Así que vamos a guardar nuestra explicación de la invocación a programas en lenguaje de máquina desde el BASIC hasta el capítulo 8, que estará completamente dedicado a la mezcla de programas en lenguaje ensamblador y programas en lenguaje BASIC.