Forme di stampa con assemblaggio per Intel 8080

Question

Così come esercizio dal mio libro di testo, sto cercando di codificare un programma in Assembly per Intel 8080 che stampierà un'immagine scalabile di tre triangoli rivolti verso il basso nella riga superiore e due rivolti verso l'alto nella riga in basso. Qualcosa del genere, per essere preciso:

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

.

E:

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

.

Come assemblaggio-novizio, però, sto avendo un momento molto difficile immaginando l'implementazione di qualcosa come questo usando solo sei registri e tenendo presente anche la scortesia della lingua stessa. Il meglio che potrei inventare è:

Sappiamo che la prima riga è 6 * altezza-1 quindi nessun problema con quello. Il problema inizia in seguito, però: sembra che dobbiamo tenere traccia (darò loro alcuni nomi per semplicità):
- outer_margin: il numero di spazi a sinistra e a destra dei triangoli esterni. Incrementa con ogni riga ma quindi non funzionerà dopo aver disegnato i triangoli superiori, quindi avremmo bisogno di un nuovo valore nel registro
- inner_spaces - spazi tra i triangoli. Innanzitutto, sarebbero stati 3, 5 e poi tre finché non arriviamo al fondo dei triangoli inferiori: il problema è che dovrebbero apparire più spesso dopo le prime due linee - up_star_counter - Biscia che acuta delle stelle da stampare per ciascuno dei triangoli superiori della linea - down_star_counter - Stesso ma per i triangoli nella riga in basso - row - Tenere traccia della riga in modo che so quando iniziare a utilizzare un set di etichette che stampiranno anche i triangoli inferiori - height - La variabile che tiene l'altezza di ciascun triangolo, come immesso dall'utente

Ciò ci dà sei valori per sei registri (e accumulatore gratuito) che non sembra troppo ottimista. Anche l'implementazione di questo sembra essere un incubo. C'è qualcosa che mi manca che in qualche modo semplificherebbe il compito o è altrettanto difficile come sembra?

Answer 1

Quello che ti manca qui è che c'è memoria libera in cui hai un sacco di spazio per memorizzare i dati variabili.

Puoi guardare qui < / a> Per ulteriori informazioni, ma in breve, dw, dd e db, (definire parola inizializzata / doppia / byte) o resb, resw, resq (definire byte / word non inizializzato / reale) creerà uno spazio per una variabile in il tuo programma Ad esempio, questo programma creerà spazio per un byte all'inizio che verrà referenziale con myvar e conterrà 5. (Syntax 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 da notare qui è che saltiamo il codice che effettivamente ha la dichiarazione dw in esso. Questa affermazione è jmp sut Int il codice sopra. Quindi ora myvar (referenziato con parentesi) può essere utilizzato proprio come una parola ordinaria.

I 6 registri sono destinati a essere utilizzati per i loop, il conteggio, i salti, ecc. Lo spazio variabile nella memoria può essere utilizzato per memorizzare una quantità enorme di dati, comprese le variabili delineate e di più.

A proposito della lingua della lingua, trovo molto più facile da far uscire il codice di assemblaggio effettuando un esempio di funzionamento in C, quindi creando un esempio di codice di assemblaggio simile.