sejo
/
compudanzas
2
3
Fork 3
Code Issues Pull Requests Projects Releases Wiki Activity

errores y traducción de código hasta el final

This commit is contained in:
maleza 2021-07-30 09:25:38 -03:00
parent 39f4501333
commit 32e3838571
1 changed files with 39 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
src/tutorial_de_uxn_día_1.gmo
View File

@ -341,7 +341,7 @@ Assembled bin/hello.rom(5 bytes), 0 labels, 0 macros.
para el curioso (¡como tu!), podemos usar una herramienta como hexdump para ver sus contenidos:
```
$ hexdump -C bin/hello.rom
$ hexdump -C bin/hola.rom
00000000 01 68 01 18 17 |.h...|
00000005
```
@ -354,7 +354,7 @@ $ hexdump -C bin/hello.rom
de hecho, podríamos haber escrito nuestro programa con estos números hexadecimales (el código máquina), y hubiera funcionado igual:
```
( hello.tal )
( hola.tal )
|0100 01 68 01 18 17 ( LIT 68 LIT 18 DEO )
```
@ -369,16 +369,15 @@ puedes encontrar los opcodes de todas las 32 instrucciones en la referencia uxnt
podemos expandir nuestro programa para imprimir más caracteres:
```
( hello.tal )
( hola.tal )
|0100 LIT 68 LIT 18 DEO ( h )
LIT 65 LIT 18 DEO ( e )
LIT 6c LIT 18 DEO ( l )
LIT 6c LIT 18 DEO ( l )
LIT 6f LIT 18 DEO ( o )
LIT 6c LIT 18 DEO ( l )
LIT 61 LIT 18 DEO ( a )
LIT 0a LIT 18 DEO ( newline )
```
si lo ensamblamos y corremos, tendremos un 'hello' en nuestra terminal, usando 30 bytes de programa :)
si lo ensamblamos y corremos, tendremos un 'hola' en nuestra terminal, usando 25 bytes de programa :)
¿ok, y... te gusta?
@ -394,9 +393,9 @@ las runas son caracteres especiales que indican a uxnasm algún pre procesamient
ya vimos la primera de ellas: | define un pad absoluto: la dirección donde el siguiente elemento escrito será ubicado en memoria.
si la dirección es de 1 byte de longitud, es asumido que es una dirección de el espacio de entrada/salidao de la página cero.
si la dirección es de 1 byte de longitud, es asumido que es una dirección de el espacio de entrada/salida o de la página cero.
si la dirección d¡es de 2 bytes de longitud, es asumido que es una dirección de la memoria principal.
si la dirección es de 2 bytes de longitud, es asumido que es una dirección de la memoria principal.
## runa hex literal
@ -407,7 +406,7 @@ hablemos de otra: #.
usando esta runa, podemos reescribir nuestro primer programa como:
```
( hello.tal )
( hola.tal )
|0100 #68 #18 DEO
```
@ -416,7 +415,7 @@ nota que sólo puedes usar esta runa para escribir los contenidos de uno o dos b
el siguiente tendría el mismo comportamiento que el programa de arriba, pero usando un byte menos (en la siguiente sección/día veremos por qué)
```
( hello.tal )
( hola.tal )
|0100 #6818 DEO
```
@ -428,15 +427,14 @@ importante: recuerda que esta runa (y las otras con la palabra "literal" en su n
nos permite que uxnasm decodifique el valor numérico de un caracter ascii.
nuestro "programa hello" luciría de la siguiente manera, usando las nuevas runas que acabamos de aprender:
nuestro "programa hola" luciría de la siguiente manera, usando las nuevas runas que acabamos de aprender:
```
( hello.tal )
( hola.tal )
|0100 LIT 'h #18 DEO
LIT 'e #18 DEO
LIT 'l #18 DEO
LIT 'l #18 DEO
LIT 'o #18 DEO
LIT 'l #18 DEO
LIT 'a #18 DEO
#0a #18 DEO ( newline )
```
@ -454,7 +452,7 @@ por ejemplo, para el dispositivo de consola, la manera en que verías esto escri
|10 @Console [ &vector $2 &read $1 &pad $5 &write $1 &error $1 ]
```
podemos ver un pad absokuto a la dirección 10, que asigna lo siguiente a esa dirección. dado que la dirección consiste en un sólo byte, uxnasm asume que es para el espacio de memoria de entrada/salida o la página cero.
podemos ver un pad absoluto a la dirección 10, que asigna lo siguiente a esa dirección. dado que la dirección consiste en un sólo byte, uxnasm asume que es para el espacio de memoria de entrada/salida o la página cero.
luego vemos la etiqueta @Console: ésta etiqueta va a corresponder a la dirección 10.
@ -478,20 +476,19 @@ la runa para referirse a una dirección literal en la página cero o el espacio
recuerda: al ser una runa de "dirección literal" va a agregar una instrucción LIT antes de la correspondiente dirección :)
podemos reescribir nuestro "programa hello world" como sigue:
podemos reescribir nuestro "programa hola mundo" como sigue:
```
( hello.tal )
( hola.tal )
( devices )
|10 @Console [ &vector $2 &read $1 &pad $5 &write $1 &error $1 ]
( main program )
( programa principal )
|0100 LIT 'h .Console/write DEO
LIT 'e .Console/write DEO
LIT 'l .Console/write DEO
LIT 'l .Console/write DEO
LIT 'o .Console/write DEO
LIT 'l .Console/write DEO
LIT 'a .Console/write DEO
#0a .Console/write DEO ( newline )
```
@ -514,49 +511,48 @@ podemos definir un macro llamado EMIT que tomará de la pila un byte correspondi
¡no olvides los espacios!
```
( print a character to standard output )
%EMIT { .Console/write DEO } ( character -- )
( escribe un caracter a la salida estandard )
%EMIT { .Console/write DEO } ( caracter -- )
```
para llamar a un macro, sólo escribimos su nombre:
```
( print character h )
( imprime caracter h )
LIT 'h EMIT
```
podemos llamar macros dentro de macros, por ejemplo:
```
( print a newline )
( imprime una nueva línea )
%NL { #0a EMIT } ( -- )
```
# un hello world más idiomático
# un hola mundo más idiomático
usando todos estos macros y runas, nuestro programa puede terminar luciendo como lo siguiente:
```
( hello.tal )
( devices )
( hola.tal )
( dispositivos )
|10 @Console [ &vector $2 &read $1 &pad $5 &write $1 &error $1 ]
( macros )
( print a character to standard output )
%EMIT { .Console/write DEO } ( character -- )
( print a newline )
( imprime un caracter en la salida estandard )
%EMIT { .Console/write DEO } ( caracter -- )
( imprime una nueva línea )
%NL { #0a EMIT } ( -- )
( main program )
( programa principal )
|0100 LIT 'h EMIT
LIT 'e EMIT
LIT 'o EMIT
LIT 'l EMIT
LIT 'l EMIT
LIT 'o EMIT
LIT 'a EMIT
NL
```
termina siendo ensamblado en los mismos 30 bytes que los ejemplos de arriba, pero con suerte más legible y mantenible.
termina siendo ensamblado en los mismos 25 bytes que los ejemplos de arriba, pero con suerte más legible y mantenible.
podemos "mejorar" este programa haciendo que un loop imprima los caracteres, pero estudiaremos eso más tarde :
@ -574,12 +570,12 @@ EMIT EMIT EMIT EMIT EMIT
## imprimir un dígito
si miras en la tabla ascii, verás que esl código hexadecimal 30 corresponde al dígito 0, 31 al dígito 1, siguiendo hasta el 39 que corresponde al dígito 9.
si miras en la tabla ascii, verás que el código hexadecimal 30 corresponde al dígito 0, 31 al dígito 1, siguiendo hasta el 39 que corresponde al dígito 9.
define un macro PRINT-DIGIT que toma un número (del 0 al 9) de la pila, e imprime el correspondiente dígito en la salida estandard.
define un macro IMPRIMIR-DIGITO que toma un número (del 0 al 9) de la pila, e imprime el correspondiente dígito en la salida estandard.
```
%PRINT-DIGIT { } ( number -- )
%IMPRIMIR-DIGITO { } ( número -- )
```
# instrucciones del día 1
@ -589,9 +585,9 @@ define un macro PRINT-DIGIT que toma un número (del 0 al 9) de la pila, e impri
* ADD: toma los dos elementos superiores de la pila, los suma, y empuja el resultado ( a b -- a+b )
* SUB: toma los dos elementos superiores de la pila, los resta, y empuja el resultado ( a b -- a-b )
* LIT: empuja el siguiente byte en memoria a la pila
* DEO: escribe el byte dado en la dirección de dispositivo dada, tomando ambos de la pila ( byte address -- )
* DEO: escribe el byte dado en la dirección de dispositivo dada, tomando ambos de la pila ( byte dirección -- )
# day 2
# día 2
¡mantente al tanto por las siguientes secciones del {tutorial uxn}!