Retro-Computación y otras cosas que hago

Luis Fernández

: Komp_Let.gif (2.24 KiB) Visto 1363 veces

EL PROGRAMA
Este programa es un pequeño compilador de lenguaje BASIC, preparado para ser ejecutado en la versión básica del ZX-81.

Introducimos una instrucción en BASIC y el compilador nos devuelve el código hexadecimal equivalente en código máquina.
Para compilar una nueva instrucción deberemos volver a ejecutar el programa con RUN.

Los comandos se deben introducir con una separación de un espacio entre la instrucción y el resto de la línea.

Esta compilador reconoce las siguientes instrucciones:

LET
Asignar un valor a una variable o incrementar el valor de una variable.
Las sumas se deben hacer con la misma variable, y no se puede asignar el valor de una variable a otra.

Ejemplos:
LET A=10
LET B=B+128
LET C=C-240

FOR
Inicio de un bucle. El valor inicial siempre debe ser 1 y el final puede tener un valor máximo de 255. No se puede usar STEP.

Ejemplo:
FOR F=1 TO 250

NEXT
Control del final de un bucle.

Ejemplo:
NEXT I

IF
Compara el valor de una variable con un valor numérico. A partir del valor numérico no es preciso escribir el resto de la línea.

Ejemplo:
IF A=050 THEN ...

GOTO
Saltar a otra posición del programa. No es preciso introducir el número de línea.

Ejemplo:
GOTO 100

GOSUB
Saltar a una subrutina. No es preciso introducir el número de línea.

Ejemplo:
GOSUB 100

RETURN
Volver de una subrutina.

Ejemplo:
RETURN

STOP
Finalizar la ejecución del programa y volver al intérprete BASIC.

Ejemplo:
STOP

PRINT
Imprimir un texto en pantalla. No es necesario introducir las comillas.

Ejemplo:
PRINT HELLO WORLD...

CLS
Borrar el contenido de la pantalla.

Ejemplo:
CLS

SCROLL
Subir una línea el contenido de la pantalla.

Ejemplo:
SCROLL

Limitaciones del compilador:
- Los nombres de las variables solo pueden contener una letra comprendida entre la “A” y la “P”.
- Las variables pueden contener un valor comprendido entre 0 y 255.
- Los valores de las variables se almacenan en la zona del buffer de la impresora. Al volver al BASIC se pierde su contenido.
- El valor numérico del IF debe contener un mínimo de 2 dígitos. Si es preciso se pueden poner 0 a la izquierda.
- La condición de un IF siempre debe ser un igual “=”, y el resultado debe ser un salto a una dirección de memoria.
- Cuando en el resultado aparece “(AD)”, se debe sustituir por la dirección de destino en hexadecimal de 16 bits (4 dígitos), indicando primero el byte bajo y después el byte alto. Esto afecta a “GOTO”, “GOSUB” y “NEXT”.

Descargar el compilador en formato ".P":

BAS1K-Compiler.rar: (859 Bytes) 50 veces

COMO FUNCIONA
A continuación detallo, línea por línea, el funcionamiento del programa.

Se utilizan las siguientes variables:
H – Variable que contiene el valor “16”.
F – Control de bucles.
A – Valor a convertir a hexadecimal.
X – Esta variable no está definida y se utiliza para detener el programa provocando un error 2.

A$ - Variable donde se guarda la línea a compilar.
B$ - Variable donde se devuelve el valor de la variable “A” en formato hexadecimal.
C$ - Variable donde se devuelve la dirección de la variable usada en la instrucción de la línea de entrada.

El programa ocupa un total de 30 líneas:
4 - Asignamos el valor 16 a la variable "H" para usarla en distintos puntos del programa.
8 - Entramos la línea a compilar.
10 - Inicio del bucle encargado de identificar la instrucción.
11 - Si las dos primeras letras de la instrucción coincide con las de la lista salta a la línea 13.
12 - Final del bucle.
14 - Si el ID de la instrucción es inferior a 9 calcula la dirección de la variable de CM.
15 - Salta a la línea con el código de la instrucción. Los ID son siempre impares.
16 - Pequeña rutina que convierte en hexadecimal el valor de "A" y lo guarda en "B$".
18 - Final de la subrutina.
20 - Compilación de FOR y parte de LET.
60 - Compilación de NEXT.
100 - Compilación de IF.
140 - Compilación de LET. Aprovecha código de la compilación de FOR.
180 - Compilación de GOTO y GOSUB.
260 - Compilación de RETURN y STOP.
300 - Compilación de CLS.
340 - Compilación de SCROLL.
380 - Compilación de PRINT.

EL PROGRAMA

APUNTES FINALES
En 1984 me compré el número 30 de la revista “El Ordenador Personal” y me dejó fascinado un pequeño programa que aparecía en la página 130. El “Trans-compilador de 1K para el ZX-81”.

Este programa convertía una instrucción en BASIC a código máquina mediante una serie de caracteres hexadecimales. Flipé.
La cantidad de instrucciones que convertía era muy reducida, y con muchas limitaciones, pero bueno. Recuerdo haberlo tecleado y usado, pero nunca intenté ejecutar el código máquina que generaba, ya que por otra parte, necesitabas un pequeño programa en BASIC para cargar esos códigos en memoria y poder ejecutar el programa.

En los últimos tiempos he conseguido realizar varios intérpretes en el ZX-81 de 1K, como el K-Assembler, el FORTH-K, ZX-LEARN, y finalmente el LOGO-K. La excepcional acogida de éste último me ha animado a enfrentarme al gran reto… el compilador de BASIC de 1K definitivo ¡!! (redoble de tambores)

Enfrentándome a los fantasmas del pasado !!!
Lo primero que hice fue teclear el “Trans-Compilador” de la revista y ejecutarlo en mi emulador.
¿Cómo podía ser que ese programa tan “raro” pudiera compilar BASIC?

En su ejecución y análisis he detectado la “trampa”, y sus limitaciones:
- Habla de variables pero realmente asigna valores a registros del microprocesador.
- Al sumar o restar 1 a una variable (no se puede usar otro valor) usa la instrucción del Z80 “INC” o “DEC”.
- Hay instrucciones que no se sabe bien como introducirlas para que se compilen.
- Los valores numéricos que devuelve están en formato decimal, lo que requiere de nuestra conversión a hexadecimal.

En resumen, muy curioso pero el código que genera es difícilmente usable, ya que por ejemplo, si los valores se almacenan en un registro, este contenido puede ser fácilmente alterado al hacer llamadas a rutinas del sistema.

Así que tocaba programar una nueva versión que generara un código “realmente” usable.

El BAS1K-Kompiler de dancresp
Mi versión del compilador genera un código 100% usable, ya que las 16 variables disponibles realmente se guardan en una posición de memoria del buffer de la impresora, y los valores se muestran en formato hexadecimal.

Únicamente las direcciones de las instrucciones de salto (CALL o JP) se muestran como “(AD)” para ser reemplazadas con el valor hexadecimal correcto posteriormente.

Hice una lista con las instrucciones que debía incorporar mi compilador, y escribir el código ensamblador equivalente. Todo debería caber en 1K, aunque como con el “K-Assembler”, esto no quiere decir que sea un primer paso para un compilador posterior más completo.

Metiendo un compilador de BASIC en 639 bytes
El ZX-81 básico dispone de 1024 bytes, de los que descontando los 125 bytes de la zona de variables del sistema y un mínimo de 25 bytes de la memoria de vídeo dejan 874 bytes libres.

La definición de variables, el calculador, el tratamiento de cadenas y la memoria de video consumen memoria, con lo que el programa no debería ocupar más de 600 bytes.

¿Y como se hace?
Lo primero ha sido introducir una línea con la que controlo la memoria que ocupa el programa en BASIC:
9999 PRINT (PEEK VAL"16396"+VAL"256"*PEEK VAL"16397")-VAL"16552"
Esta línea ocupa 43 bytes, que ganaré al borrarla al finalizar el desarrollo del programa, o al aparecer el maldito error 4.

Como siempre, he usado los trucos habituales del ZX-81 para ahorrar memoria en el uso de valores numéricos. Así, "NOT PI" es 0, uso de CODE y VAL, y como el valor 16 se usa varias veces, he asignado ese valor a la variable "H".

¿Cómo se guarda las líneas BASIC el ZX-81?
En un principio mi intención era escribir la línea mediante el propio editor del ZX-81, escribiéndola en la primera línea del programa en BASIC, y procesarla desde el BASIC con una llamada tipo “RUN 100”. Era una forma sencilla de hacerlo, ya que el programa se guarda a partir de la posición 16509, y cada instrucción tiene un Id único. Esto me facilitaba la parte que salta a la rutina correspondiente.

El ejemplo anterior, muestra como se guardan las líneas en un programa en BASIC:
- Los dos primeros bytes contienen el número de línea.
- Los siguientes dos bytes contienen la longitud de la línea, excluyendo estos primeros 4 bytes.
- Contenido de la línea, carácter a carácter, en los que se sustituyen los comandos por su identificador único (Token), y un bloque especial de 6 bytes cuando hay valores numéricos.
- Bytes con un “118” que indica el final de línea.

Y el porque de los números...
Este mismo ejemplo sirve para comprender porque usando la instrucción CODE o VAL conseguimos ahorrar memoria cuando una línea contiene valores numéricos.

Como se puede ver, a parte de guardar el valor numérico dígito a dígito, a continuación guarda un bloque de 6 bytes, empezando siempre con un “126” que contienen el valor en un formato empaquetado, comprensible por el calculador.

Cuando se hace un LIST se muestran los dígitos hasta encontrar el código “126”, se suman 5 bytes para saltarse el bloque y sigue listando.

Pero cuando se ejecuta el programa se trabaja con los 5 bytes a partir del “126” y de esta forma el intérprete es más rápido, ya que tiene el valor en un formato comprensible por el calculador.

Al usar VAL o CODE, este bloque de 6 dígitos no se incluye, pero como la instrucción VAL ó CODE más las dos comillas de inicio y final ocupan 3 bytes, el ahorro queda en 3 bytes. En función de los dígitos del número, el ahorro de memoria puede aumentar o disminuir.

Al usar NOT PI, SGN PI, INT PI y otros, el ahorro puede llegar a los 4 ó 5 bytes.

Comienza la pesadilla...
Realmente, programar este compilador ha sido todo un reto.

Precisamente por la forma como el BASIC del ZX-81 se guarda los valores numéricos no me ha permitido hacer el análisis de la línea de la forma que yo quería, y he decidido hacer la entrada mediante un INPUT y guardarla en la variable A$.

Un clásico bucle comprendido entre las líneas 10 y 12 me permite identificar la instrucción y posteriormente saltar a la línea que la procesa y compila.

Las instrucciones están ordenadas de forma que primero trato las que usan variables, para que con una línea común (14) pueda obtener un código entre “0” y “F”, en función de la variable usada, y guardar la dirección de memoria completa en la variable “C$”. Debido a esto, solo puedo usar 16 variables, de una letra.

Una sencilla rutina en la línea 16 convierte el valor de la variable “A” en un código hexadecimal de 2 bytes, que se guarda en la variable “B$”.

Cada vez que se compila una línea finaliza la ejecución del programa. Para conseguirlo, he hecho referencia a la variable “X” en el PRINT correspondiente. Como no existe, da un error 2 y detiene la ejecución. Esto me ha ahorrado líneas… y memoria.

En el caso de las instrucciones NEXT y LET, gran parte del código es compartido ya que en el fondo lo único que hacen es asignar un valor a una variable, y lo único que varía es la posición del valor numérico.

Como usar el compilador
El funcionamiento del compilador es muy sencillo, y en si se podría decir que se compone de 4 pasos, tal y como se puede ver en el siguiente esquema.

Pasos de la compilación:
1. Se escribe el programa, por ejemplo en un papel.
2. Se introducen las líneas en el compilador y se apunta el código resultante.
3. Se calcula la dirección de memoria de cada línea, teniendo en cuenta que la primera dirección debe ser la 16514 (4082h). Cada 2 caracteres hexadecimales corresponden a un byte.
4. Se sustituyen los “(AD)” por la dirección correcta, teniendo en cuenta que se deben invertir el orden de los dos pares de bytes. Esto es así para GOTO, GOSUB y NEXT. En este último caso debe saltar a la siguiente dirección de la línea que contiene el FOR, ya que sino entraría en un bucle infinito.

Una vez finalizado, se deberá cargar el código hexadecimal en la memoria...

Probando el código compilado
Ahora falta cargar el código en memoria para poder ejecutar el programa.

Pasos de la carga del código máquina:
1. Poner en la línea 1 REM tantos caracteres como bytes tenga el programa y cargar el código hexadecimal en la variable A$ de la línea 10.
2. Ejecutar el programa para cargar el código hexadecimal en la línea REM. Como se puede ver, los caracteres han cambiado.
3. A continuación se han de borrar desde la línea 10 hasta la 70, y se crea una línea 10 con un USR 16514.
4. Al hacer RUN el BASIC ignora el contenido de la línea REM pero si ejecuta el USR, y muestra el resultado del programa.

A partir de aquí, el programa se puede grabar en una cinta de cassette con un simple SAVE ”nombre” para poderlo cargar posteriormente.

También es recomendable hacer una grabación del programa antes de pasar al paso 2, ya que en caso de error al introducir el código hexadecimal se podría volver a cargar y revisar lo introducido. En este caso también se debe hacer con SAVE.

Programa cargador “limpio”:

: CM-Loader.gif (2.93 KiB) Visto 1302 veces

En el supuesto que el programa a cargar sea muy largo, la línea 30 se debería sustituir por:

30 IF A$=”” THEN INPUT A$

Y se deberían introducir los códigos en grupos reducidos.

Rendimiento
A modo de ejemplo, el programa compilado se limita a mostrar 250 letras “A” en pantalla, una a continuación de la otra.

En BASIC el programa tarda aproximadamente unos 5,7 segundos, y en código máquina a tardado menos de 0,2 segundos.

Está claro que no es el mejor ejemplo para hacer una prueba de rendimiento ya que el código máquina puede ser miles de veces más rápido que el BASIC, pero incluso así, ha sido bastante más rápido.

Pues nada más, solo me queda desearos una muy feliz compilación !!!

El compilador se ha desarrollado íntegramente en el emulador “EightyOne” de Windows.

Os invito a probarlo.

: Komp_Print.gif (2.88 KiB) Visto 1363 veces

: Komp_For.gif (2.07 KiB) Visto 1363 veces

: Komp_Next.gif (2.19 KiB) Visto 1363 veces

: Komp_If.gif (2.33 KiB) Visto 1363 veces

: Komp_Let.gif (2.24 KiB) Visto 1363 veces

Luis Fernández

Hola amigos, hace mucho que le doy la vueltas en la cabeza con este tema recurrente, y ahora recientemente, me he enfrascado más con Assembler.
Como soy rebelde, y nada conformista, tengo pensamientos radicales y le busco el porque a las cosas y a esto no se lo encuentro el porque.

Veamos: al principio de los tiempos del lenguaje de maquina, a unos ingenieros se les ocurrió una nomenclatura para nombrar las instrucciones numéricas (lenguaje de máquina), que usaban sus procesadores, y nada, le dieron nombres y se quedaron tan felices, y a comer perdices, hasta nuestros tiempos y después de 300 generaciones de CPUS, aún se usa lo mismo, pues por mi, se podían haber quedado quietos, porque para mi no lo hicieron del todo bien.

Se que eran ingenieros de electrónica y no sabrían mucho de lenguaje y tal, pero de matemáticas deberían saber, así que no hay escusa.

Expliquen lo siguiente:

Porque si un niño de 13 años sabe que lo que significa A = 27, a estos ingenieros se les ocurrió que era mejor decir LDA 27, no lo se pero trastocaron todo, ademas, tienes que aprender un lenguaje nuevo, que aunque no es muy difícil, hay que aprenderlo, y no usaron una notación tan obvia como A = 27

Cuando escribimos assembler siempre ponemos en los comentarios cosas como A = 0 o cargar en A el valor de tal cosa fíjense en todos los assemblers

Si usaran esta notación matemática todo seria mas fácil, fíjense en la ultima columna NOTAS de este set de Z80 aquí listado completo

MASS.ZIP: (5.85 KiB) 97 veces

y la pagina de donde sale http://wiki.speccy.org/cursos/ensamblador/lenguaje_5
Siempre hay que estar comentando, como en esa ultima columna

Se podrian escribir cosas como en basic
A = $27: B = 45: y asi sin tener que comentar tanto, casi se podria hacer estructurado

Se que dirán que ADD A, 27 es mas fácil que A = A + 27, pero este ultimo no tienes que aprenderlo ya lo sabes de antemano y total para la maquina es igual

Podríamos poner varios comandos en una linea y no interminables listas con comentarios,
Se podría poner indentados, los loops
GOTO aunque no gustan, pero serian visibles
hasta un niño lo entendería

CÓDIGO: SELECCIONAR TODO: --------------+----+---+------+------------+---------------------+----------------------- |Mnemonic |Clck|Siz|SZHPNC| OP-Code | Description | Notes | --------------+----+---+------+------------+---------------------+----------------------- |ADC A,r | 4 | 1 |***V0*|88+rb |Add with Carry |A=A+s+CY |A=A+?+C |ADD A,r | 4 | 1 |***V0*|80+rb |Add (8-bit) |A=A+s |A=A+? |AND r | 4 | 1 |***P00|A0+rb |Logical AND |A=A&s |A=A AND ? |CALL NN | 17 | 3 |------|CD XX XX |Unconditional Call |-(SP)=PC,PC=nn | |CPL | 4 | 1 |--1-1-|2F |Complement |A=~A |A=~A |DEC A | 4 | 1 |***V1-|3D |Decrement (8-bit) |s=s-1 |s=s-1 |EX (SP),HL | 19 | 1 |------|E3 |Exchange |(SP)<->HL | |JP $NN | 10 | 3 |------|C3 XX XX |Unconditional Jump |PC=nn | |JR $N+2 | 12 | 2 |------|18 XX |Relative Jump |PC=PC+e | |LD I,A | 9 | 2 |------|ED 47 |Load* |dst=src |NEG | 8 | 2 |***V1*|ED 44 |Negate |A=-A | |OR r | 4 | 1 |***P00|B0+rb |Logical inclusive OR |A=Avs | |RET | 10 | 1 |------|C9 |Return |PC=(SP)+ | |SCF | 4 | 1 |--0-01|37 |Set Carry Flag |CY=1 | |SUB r | 4 | 1 |***V1*|90+rb |Subtract |A=A-s | |XOR r | 4 | 1 |***P00|A8+rb |Logical Exclusive OR |A=Axs |

Veamos este trozo

L_6D31:

 CALL L_6E97   ; 6D31 CD 97 6E                 * Busca el final del Buffer de entradas
 CP $D0        ; 6D34 FE D0     A = $D0?       * Compara con $D0
 JR Z, L_6DA2  ; 6D36 28 6A     Z = 1          * Si es cero salta a L_6DA2
 CP $90        ; 6D38 FE 90     A = $90?       * Compara con $90
 JR NZ, L_6D6C ; 6D3A 20 30     Z = 0?         * si no es cero salta a L_6D6C
 LD A, B       ; 6D3C 78        A = B          * A = $40
 AND $0F       ; 6D3D E6 0F     A = A AND $0F  * 
 OR C          ; 6D3F B1        A = A OR C     * A = A OR 5
 JR NZ, L_6D6C ; 6D40 20 2A     Z = 0?         * Si no es cero salta a L_6D6CL_6D6C
 LD A, (L_B71B); 6D42 3A 1B B7  A = (L_B71B)   * Toma un dato de DATABLK1
 AND A         ; 6D45 A7        A = A AND A    * Adecua flags
 JR NZ, L_6D4E ; 6D46 20 06     Z = 0          * Si no es cero salta a L_6D4E
 INC A         ; 6D48 3C        A = A + 1      * Es cero, Incrementa A, A = 1
 LD (L_B71B), A; 6D49 32 1B B7  (L_B71B) = A   * (L_B71B) = 1, inicializa dato en DATABLK1
 JR L_6D6C     ; 6D4C 18 1E                    * Salta a L_6D6C

Yo lo escribiría así:

CÓDIGO: SELECCIONAR TODO: L_6D31: PC = L_6E97 A = $D0?: IF Z=1 GOTO L_6DA2 A = $90? : IF Z=0 GOTO L_6D6C A = B: A = A AND $0F: A = A OR 5: IF Z=0 GOTO L_6D6C A = (L_B71B): A = A AND A: IF Z=0 GOTO L_6D4E A = A + 1: (L_B71B) = A: GOTO L_6D6C

O ASI

CÓDIGO: SELECCIONAR TODO: L_6D31: PC = L_6E97 A = $D0? IF Z=1 GOTO L_6DA2 A = $90? IF Z=0 GOTO L_6D6C A = B A = A AND $0F A = A OR 5 IF Z=0 GOTO L_6D6C A = (L_B71B) A = A AND A IF Z=0 GOTO L_6D4E A = A + 1 (L_B71B) = A GOTO L_6D6C

Los GOTO L_6D6C, Pueden ser PC = L_6D6C

No es que sea perfecto pero el 70% puede ser así, algunos comandos serian de la forma tradicional.

Creo que es digno de estudiarse y no simplemente seguir a todos como borregos, desde hace 30 años

Fácilmente puedo hacer un compilador que entienda los dos formatos, llamemosles (tradicional y matemático)