Programando en Turbo Assembler en los 90
Tags: spanish, retro, assembly, learning
Published: 2023-10-13 10:41:10

---
title: Programando en Turbo Assembler en los 90
published: true
description: 
tags: #spanish #retro #assembly #learning
# cover_image: https://direct_url_to_image.jpg
# Use a ratio of 100:42 for best results.
# published_at: 2023-10-04 08:33 +0000
---

[Borland](https://es.wikipedia.org/wiki/Borland) empezaba a ser una compañía de desarrollo importante en los 90. Durante los 80, había comercializado el excelente Turbo Pascal, un compilador con un entorno de programación integrado que era capaz de dejar buena parte de la memoria libre para nuestros programas, y se realmente rápido compilando, para además crear ejecutables realmente pequeños.

Posteriormente, Borland vendería además Turbo Basic y Turbo Prolog, pero sería con el compilador Turbo C (todos ellos con entorno integrado incluído), con el que lograría una gran fama y un gran éxito en ventas. Las razones eran las mismas que con Turbo Pascal: un entorno integrado incluído en el ejecutable dejando mucha memoria libre, pequeños ejecutables y compilación muy rápida. En los 90, además, saldría Turbo C++, que cubría además C++, y que eliminaría para siempre el nombre Turbo C.

![Turbo C++](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/6ep21fi5u7lz5hikl5is.jpg)

Borland completaría además estos poderosos compiladores con TASM o Turbo Assembler, TLINK o Turbo Linker, y su propia versión de la utilidad **make**.

Los problemas de obsolescencia que no me permitieron compilar ensamblador en el artículo sobre [los monitores de 17" de los 90](https://dev.to/baltasarq/es-cuando-tenias-un-crt-de-17-3l89) me hicieron pensar en cómo podría recrear un entorno de programación de aquella época. Y la solución fue: [DosBOX](https://www.dosbox.com/).

![DosBOX](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/kk899rjcq9x81ij58qoh.png)

Obtuve de un [repo sobre TASM en GitHub](https://github.com/qb40/tasm) un archivo comprimido que descomprimí en un directorio llamado, atención... **tasm/**.

Pero necesitaba un editor de texto. En aquella época, yo utilizaba sobre todo **ne**, el *Norton Editor*, cuando programaba en Pascal, C, o Clipper. Era un muy pequeño editor con muchas posibilidades (muchas de ellas solo las encontraríamos mucho más tarde), con un acceso rápido a la ayuda con F1 (lo dicho, algunos editores son alérgicos a algo tan sencillo como esto) y en definitiva, una pequeña maravilla muy superior al **edit** de Microsoft, que aparecería con **QBasic** (un intérprete de Basic de Microsoft).

Lo localicé en una [web de utilidades para MS-DOS](http://www.dcee.net/Files/Utils/), y simplemente lo copié en mi directorio **tasm/**.

Solo quedaba lanzar **DosBOX** con `dosbox .` desde el directorio **tasm/**.

Bueno, necesitamos una distribución de teclado española:

    c:\> keyb sp

Y necesitamos crear el archivo ensamblador con **ne**.

    c:\> ne modex.asm

Para pasar a 40x25, tendríamos que utilizar el siguiente código:

```asm
; modo 40x25

MODEL tiny

.code

ORG 100h

main:
        ; Cambiar el modo de texto
        MOV ah, 0    ; cambia modo de texto
        MOV al, 1    ; 40x25 en color
        INT 10h

        MOV ah, 4ch  ; volver al DOS
        MOV al, 0    ; valor de retorno
        INT 24h
END main
```

De acuerdo, el código es el mismo que el del anterior artículo: el primer bloque de código invoca a la BIOS con la llamada 0 (cambia modo de vídeo) y el argumento 1 (40x25 color), mientras que el segundo bloque lo que hace es llamar a MS-DOS para terminar el programa y volver al sistema operativo.

![Norton Editor o ne](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/yk4b0ea77oqumebs0vxw.png)

Curiosamente, no funciona bien. Claramente cambia el modo de vídeo, pero se queda colgado en lugar de volver al DOS. ¿Alguna idea? ¡Pónmelo en los comentarios!

En cualquier caso, guardamos nuestro programa como `modex.asm`. Para ensamblar el código, necesitamos ejecutar **tasm**.

    c:\> bin\tasm modex.asm

Esta instrucción generará el archivo objeto `modex.obj`. Tenemos que enlazarlo para generar un ejecutable, que será un COM (el ejecutable más sencillo de todos, de ahí la línea `MODEL tiny`), gracias a la opción `-t`.

    c:\>bin\tlink -t modex.obj

Ahora tenemos el ejecutable, por lo que solo es cuestión de ejecutar:

    c:\> modex

Con lo que el modo de texto cambia a 40x25 en color, pero desgraciadamente no es capaz de volver a MS-DOS correctamente, se queda colgado.

En cualquier caso, es un poco lioso estar constantemente introduciendo estos comandos. Un archivo **Makefile** nos simplificará bastante la vida.

    c:\> ne Makefile

De acuerdo, el contenido es:

```make
modex: modex.asm
        bin\tasm modex.asm
        bin\tlink -t modex.obj

clean:
        del *.obj
        del modex.com
        del *.map
        del *.@as
```

Tiene dos secciones. La primera es la importante, que le explica a `make` cómo crear el ejecutable `modex.com`. Después de los dos puntos, incluimos `modex.asm`. De esta manera, `make` sabe si es necesario recompilar de nuevo: si ha habido cambios en `modex.asm` sí, y no en caso contrario. Esto es lo que se llama dependencias, y en este caso solo hay una.

A continuación, con un tabulador delante, indicamos las instrucciones necesarias, una detrás de otra, para generar ese ejecutable.

Para hacerlo, solo será necesario:

    c:\> make

Y tendremos nuestro `modex.com` en el directorio, con lo que solo será necesario ejecutarlo.

La segunda sección es `clean`. Aquí no hay ninguna dependencia y le explicamos a `make` lo que tiene que hacer al recibir esta orden que es "limpiar" el directorio de archivos resíduo del enamblado y enlazado. Para hacerlo, solo es necesario:

    c:\> make clean

La herramienta `make` es muy poderosa y se emplea muy frecuentemente en proyectos actuales.

¿Alguien ha sentido nostalgia?