Impresión de formas con ensamblaje para Intel 8080

Question

Entonces, como ejercicio de mi libro de texto, estoy tratando de codificar un programa en ensamblador para Intel 8080 que imprimirá una imagen escalable de tres triángulos boca abajo en la fila superior y dos boca arriba en la fila inferior.Algo así, para ser precisos:

*****************************
 *******   *******   *******
  *****     *****     *****
   ***   *   ***   *   ***
    *   ***   *   ***   *
       *****     *****
      *******   *******
     *******************
(when user selects the height variable = 5)

y:

*****************************************  
 ***********   ***********   ***********
  *********     *********     *********  
   *******   *   *******   *   *******
    *****   ***   *****   ***   ***** 
     ***   *****   ***   *****   ***
      *   *******   *   *******   *
         *********     *********
        ***********   ***********
       ****************************
(when user selects the height variable = 7)

Sin embargo, como novato en ensamblaje, me cuesta mucho imaginar la implementación de algo como esto usando solo seis registros y también teniendo en cuenta lo hostil del lenguaje en sí.Lo mejor que se me ocurrió es:

Sabemos que la primera fila es 6*alto-1, así que no hay problema con eso.Sin embargo, el problema comienza más tarde:parece que tenemos que realizar un seguimiento de (les daré algunos nombres para simplificar):
- outer_margin - el número de espacios a la izquierda y a la derecha de los triángulos exteriores.Se incrementa con cada línea pero luego no funcionará después de dibujar los triángulos superiores, por lo que necesitaríamos un nuevo valor en el registro.
- inner_spaces - espacios entre los triángulos.Primero, serían 3, 5 y luego tres hasta llegar al final de los triángulos inferiores; el problema es que tendrían que aparecer con más frecuencia después de las dos primeras líneas.
- up_star_counter - realizar un seguimiento de las estrellas para imprimir para cada uno de los triángulos superiores de la línea
- down_star_counter - lo mismo pero para los triángulos en la fila inferior
- row - realizar un seguimiento de la fila para saber cuándo comenzar a usar un conjunto de etiquetas que también imprimirán los triángulos inferiores
- height - la variable que contiene la altura de cada triángulo, ingresada por el usuario

Eso nos da seis valores para seis registros (y un acumulador gratuito), lo que no parece demasiado optimista.Además, la implementación de esto parece ser una pesadilla.¿Hay algo que me falta aquí que de alguna manera simplificaría la tarea o es tan difícil como parece?

Answer 1

Lo que te falta aquí es que haya memoria libre donde tengas mucho espacio para almacenar datos variables.

Usted puede mirar aquí para más información, pero en resumen, dw, dd, y db, (definir palabra/doble/byte inicializado) o resb, resw, resq (definir byte/palabra/real no inicializado) creará un espacio para una variable en su programa.Por ejemplo, este programa creará espacio para un byte al principio al que se hará referencia con myvar, y contendrá 5.(Sintaxis NASM)

[BITS 16]                           
[ORG 0x7C00]                        
jmp Start

myvar dw 5                  

Start:
    mov word bx, [myvar]

End:
    jmp $                   

times 510-($-$$) db 0           
dw 0xAA55   

Una cosa importante a tener en cuenta aquí es que omitimos el código que realmente tiene la declaración dw en eso.Esta declaración es jmpHabía repasado el código anterior.Y ahora myvar (referenciado entre corchetes) se puede utilizar como una palabra normal.

Los 6 registros están destinados a usarse para bucles, conteo, saltos, etc.El espacio variable en la memoria se puede utilizar para almacenar una gran cantidad de datos, incluidas las variables que describió y más.

En cuanto a la hostilidad del lenguaje, me resulta mucho más fácil desarrollar el código ensamblador haciendo un ejemplo funcional en C y luego creando un ejemplo de código ensamblador similar.