Commodore 64: Ritorno alle origini!

Tweet

Se qualcuno mi chiedesse qual è il computer che ha maggiormente segnato l'home computing in Italia, non esiterei a rispondere: il Commodore 64!
A metà degli anni ottanta, macchine come il Vic 20 ed il Commodore 64 erano le protagoniste indiscusse del panorama informatico italiano di quegli anni.
Anzi, per dirla tutta, il Commodore 64 non veniva considerato come UN computer ma come IL computer (con buona pace per tutti i fan Sinclair!), più vicino ad un oggetto di cult che ad una semplice macchina. Inoltre, dato l'enorme successo riscosso, fiorivano riviste mitiche quali: Superfloppy 64, Commodore Computer Club, Commodore Gazzette, Bit, MC Micro Computer, Papersoft e tante altre.
Insomma la Commodore ha scritto la storia dell'informatica in Italia (e, forse, nel mondo), facendo appassionare all'informatica tantissime persone, contribuendo anche a realizzare il sogno di Bill Gates: un computer in ogni casa.
Oggi, ad oltre trent'anni di distanza, il ricordo di quel periodo è sempre vivo in chi, come il sottoscritto, lo ha vissuto.
Me ne rendo conto navigando su internet dove è possibile scaricare in modo gratuito tanti emulatori del Commodore 64 e moltissimo software ad esso dedicato.
Ancora oggi ci sono tantissimi appassionati che si dilettano a realizzare programmi per questo meraviglioso computer.
Un'ottima testimonianza è costituita dall'intervento del bravo Giovanni Simotti che, al codemotion 2012, ha efficacemente illustrato come ancora oggi, ad oltre trent'anni dalla sua nascita, sia possibile programmare il Commodore 64 con strumenti moderni.
Così anch'io mi sono detto: perchè non riprovarci? Ed allora, di buona lena, ho deciso di mettermi all'opera ed ho deciso di scrivere un'implementazione dell'algoritmo per lo sviluppo di sistemi integrali del totocalcio, presentato nel primo topic di questo blog.
La prima cosa che ho fatto è stata quella di procurarmi un buon emulatore.
La scelta è caduta sull'ottimo VICE che, oltre ad emulare diversi tipi di macchina di casa Commodore, dispone anche di un ottimo debbugger le cui modalità di utilizzo sono descritte abbastanza bene su questo link.
La seconda è stata quella di procurarmi un buon IDE che semplificasse la scrittura del programma da eseguire con l'emulatore.
La scelta è caduta sull'ottimo CBM .prg Studio di Arthur Jordison che permette di scrivere in modo ottimale programmi per vari tipi di computer di casa Commodore quali: VIC 20, Commodore 64, Commodore 128, Commodore 16, Plus/4 e Pet.
Una volta avuti a disposizione tali strumenti di sviluppo, ho provveduto a scrivere una prima stesura in basic dell'algoritmo che desideravo implementare.
Il codice che ho sviluppato è il seguente:

10 input"{clear}quante parite";n
20 if n<1 or n>16 then 10

30 dim bs(n): cs=1: pr$="": print: for i=1 to n
40 print"partita n.";i;"{left}";: input p$
50 cs=cs*len(p$): bs(i)=len(p$): pr$=pr$+p$
60 next: print: print"{down}colonne da sviluppare:"; cs
70 print: for i=1 to cs: gosub 80: print cl$: next: end
80 cl$="": pt=len(pr$)-bs(n): nc=i-1: for j=n to 1 step -1
90 cl$=mid$(pr$, nc-int(nc/bs(j))*bs(j)+pt+1, 1)+cl$
100 nc=int(nc/bs(j)):if j>1 then pt=pt-bs(j-1)
110 next: return

Tale programma, sebbene sia di dimensioni molto ridotte ed eseguibile praticamente su tutte le macchine di casa Commodore, ha il difetto di non essere facilmente "traducibile" in assembler.

Il motivo di tale difficoltà deriva dal fatto che non è semplice eseguire un conteggio per numeri maggiori di 255 su macchine a 8bit.

Per tale motivo, per ovviare a tale difficoltà, ho riscritto il programma in modo tale che il conteggio non sia più eseguito con un ciclo ma mediante operazioni più "semplici".

Per fare ciò, mi sono "ispirato" ad un contatore eseguito su una macchina di Turing. Chiunque voglia vedere come questo funzioni su una tale macchina, può visitare il sito, oppure scaricare il simulatore dal sito.

Il nuovo codice sviluppato, di cui lascio ai volenterosi il compito di capirne i dettagli implementativi, è il seguente:

10 input"{clear}quante parite";n
20 if n<1 or n>16 then 10
30 dim a(n), bs(n): cs=1: pr$="": print: for i=1 to n
40 print"partita n.";i;"{left}";: input p$
50 cs=cs*len(p$): bs(i)=len(p$): pr$=pr$+p$
60 next: print: print"{down}colonne da sviluppare:"; cs
70 ps=n: dr=0: print: for i=1 to n: a(i)=0: next
80 gosub 170
90 a(ps)=a(ps)+1
100 if a(ps)
110 dr=1
120 ps=ps-1: if ps>0 then a(ps)=a(ps)+1
130 if ps>0 and a(ps)=bs(ps) and dr=1 then 120
140 if a(1)=bs(1) then end
150 for i=ps+1 to n: a(i)=0: next
160 ps=n: dr=0: goto 100
170 pt=0: for i=1 to n: print mid$(pr$, a(i)+pt+1, 1);: pt=pt+bs(i): next
180 print: return

A questo punto, mi proposi di "tradurre" tale programma in assembler, ma desideravo che il codice che sarei andato a realizzare fosse multipiattaforma; ossia che potesse essere eseguito non solo su Commodore 64 ma anche su altre macchine quali: Vic 20, Commodore 128, Commodore 16 e Plus4.

Per fare ciò, ho fatto largo utilizzo dell'indirizzamento indiretto indicizzato basandolo sulle locazioni 251($FB) e 252($FC) di pagina zero. La scelta è caduta su di esse in quanto le locazioni da 251 a 254 in pagina zero sono libere su tutte le macchine cbm.

Inoltre, ho dovuto rinunciare all'utilizzo dell'istruzione JMP basando i salti all'interno del codice sulle istruzioni CLC e BCC.

Ho cercato di eseguire la "traduzione" in assembler, per quanto possibile, riga per riga e commentando il codice indicando anche l'inizio della corrispettiva riga in basic (relativa al codice precedente).

Il codice che ho scritto, che anche in questo caso lascio ai volenterosi il compito di capirne i dettagli implementativi, è il seguente:

; Tot16

*=$C000

start  LDY #$0
       LDA ($FB),Y
       TAY
       LDA #$0
loop1  STA ($FB),Y
       DEY
       BNE loop1
       LDA ($FB),Y
       TAY         ; y=n
       LDX #$0     ; x=0
cllprt JSR subprt  ; Chiama la subroutine per stampare la colonna   ** Riga 80 **
       CLC
       LDA ($FB),Y ; a(y)=a(y)+1
       ADC #$1
       STA ($FB),Y
loop2  PHA         ; tmp=a(y)
       TYA         ; y=y+n
       CLC
       LDY #$0
       ADC ($FB),Y
       TAY
       PLA         ; a=tmp
       CMP ($FB),Y ; if a(y)==b(y) || x==1 then chgdr   ** Riga 100 **
       BEQ chgdr
       CPX #$1
       BEQ chgdr
       PHA         ; tmp=a
       TYA         ; y=y-n
       SEC
       LDY #$0
       SBC ($FB),Y
       TAY
       PLA         ; a=tmp
       CLC         ; JMP cllprt
       BCC cllprt
chgdr  LDX #$1     ; x=1     ** Riga 110 **
       PHA         ; tmp=a
       TYA         ; y=y-n
       SEC
       LDY #$0
       SBC ($FB),Y
       TAY
       PLA         ; a=tmp
loop3  DEY         ; y--     ** Riga 120 **
       CPY #$0
       BEQ chkend
       CLC         ;         ** Riga 130 **
       LDA ($FB),Y ; a=a(y)+1
       ADC #$1
       STA ($FB),Y
       PHA         ; tmp=a
       TYA         ; y=y+n
       LDY #$0
       ADC ($FB),Y
       TAY
       PLA         ; a=tmp
       CMP ($FB),Y ; if a!=b(y)
       BNE chkend
       CPX #$1
       BNE chkend
       PHA         ; tmp=a
       TYA         ; y=y-n
       LDY #$0
       SEC
       SBC ($FB),Y
       TAY
       PLA         ; a=tmp
       CLC         ; JMP loop3
       BCC loop3
jmplp2 CLC         ; JMP loop2
       BCC loop2
chkend TYA         ; y=y-n   ** Riga 140 **
       LDY #$0
       SEC
       SBC ($FB),Y
       TAY         ; y=a
       PHA         ; tmp=a
       LDY #$0
       LDA ($FB),Y
       TAY
       INY
       LDA ($FB),Y ; a=b[1]
       LDY #$1
       CMP ($FB),Y
       BEQ end
       PLA         ; a=tmp
       TAY
loop4  INY         ; ** Riga 150 **
       TYA         ; a=y
       PHA         ; tmp=a
       LDA #$0
       STA ($FB),Y
       PLA         ; a=tmp
       LDY #$0
       CMP ($FB),Y
       BEQ endres
       TAY         ; y=a
       CLC         ; JMP loop4
       BCC loop4
endres LDX #$0     ; ** Riga 160 **
       TXA
       TAY
       LDA ($FB),Y
       TAY
       LDA ($FB),Y ; a=a[n]
       CLC         ; JMP loop2: è necessario un salto più "piccolo" a jmpl2
       BCC jmplp2
end    PLA          ; Svuota lo stack
       RTS
; Subroutine per stampare la colonna
subprt PHA         ; Salva l'accumulatore nello stack
       TXA
       PHA         ; Salva il registro x nello stack
       TYA
       PHA         ; Salva il registro y nello stack
       LDX #$0     ; x=0
       LDY #$0     ; y=0
       TYA         ; tmp=y
       PHA
loop5  PLA         ; y=tmp
       TAY
       INY         ; y=y+1
       TYA         ; tmp=y
       PHA
       TXA         ; a=x+a(y)+1+n*2
       CLC
       ADC ($FB),Y
       ADC #$1
       LDY #$0
       ADC ($FB),Y
       ADC ($FB),Y
       TAY         ; y=a
       LDA ($FB),Y ; stampa il carattere
       JSR $FFD2
       PLA         ; a=y(originario corrispondente allo i-esimo)
       PHA
       LDY #$0     ; x=x+a(y+n)
       ADC ($FB),Y
       TAY       
       LDA ($FB),Y
loop6  INX
       SEC
       SBC #$1
       BNE loop6
       LDY #$0     ; Compara l'y originario con n
       PLA
       PHA
       CMP ($FB),Y
       BNE loop5   ; Se non coincide continua con la stampa
       LDA #$D
       JSR $FFD2
       PLA         ; Svuota lo stack
       PLA         ; Recupera il registro y dallo stack
       TAY
       PLA         ; Recupera il registro x dallo stack
       TAX
       PLA         ; Recupera l'accumulatore dallo stack
       RTS         ; Esce dalla subroutine

Una volta scritto tale codice, restava da scriverne il loader che si occupasse di caricarlo in memoria, rilocandolo a seconda della macchina su cui viene eseguito.

Gli unici due problemi da risolvere erano i seguenti: individuare il tipo di macchina in cui il codice viene eseguito e determinare la posizione dove allocare il programma assembler nella memoria di tale macchina.

In merito al primo problema, su internet ho trovato la seguente discussione da cui ho estratto lo snippet che ho utilizzato nel mio codice.

Per quanto riguarda il secondo, invece, ho pensato di allocare il codice 2k dopo l'inizio dell'area dedicata ad ospitare il codice basic che su tutte le macchine cbm può essere individuata grazie alle locazioni 43 e 44.

Per il Commodore 64, sebbene non necessario, ho preferito scegliere in modo deterministico l'area di memoria che inizia all'indirizzo 49152($C000).

Infine, faccio esplicitamente osservare che, limitatamente alla sola istruzione "JSR subprt", si è reso necessario modificare 2 byte del codice assembler in funzione dell'indirizzo di memoria determinato per l'inizio del programma.

Il codice che ho scritto per fare ciò è il seguente:

10 cbm=peek(65534)
20 if peek(1177)=63 then poke1177,62: cbm=peek(65534): poke1177,63
30 if cbm=72 or cbm=114 or cbm=23 or cbm=179 then 50
40 print "solo per: c64, vic20, c128, c16, plus4": end
50 if cbm=72 then sa=49152: goto 70
60 sa=peek(44)*256+peek(43)+1024*2
70 o=235: for i=0 to o-1: read a: poke sa+i,a: next
80 input"{clear}quante parite";n
90 if n<1 or n>16 then 80
100 poke sa+o,n: cs=1: pr$="": print
110 for i=1 to n
120 print"partita n.";i;"{left}";: input p$
130 cs=cs*len(p$): poke sa+o+n+i,len(p$): pr$=pr$+p$
140 next: print: print"{down}colonne da sviluppare:"; cs
150 for i=1 to len(pr$): poke sa+o+n*2+i,asc(mid$(pr$, i, 1)): next
160 hi=int((sa+o)/256): lo=(sa+o)-hi*256: poke 251,lo: poke 252,hi
170 rem modifica nel codice l'indirizzo della chiamata a subprt
180 hi=int((sa+166)/256): lo=(sa+166)-hi*256: poke sa+18,lo: poke sa+19,hi
190 sys sa

200 end
210 data 160,0,177,251,168,169,0,145
220 data 251,136,208,251,177,251,168,162
230 data 0,32,166,192,24,177,251,105
240 data 1,145,251,72,152,24,160,0
250 data 113,251,168,104,209,251,240,16
260 data 228,1,240,12,72,152,56,160
270 data 0,241,251,168,104,24,144,217
280 data 162,1,72,152,56,160,0,241
290 data 251,168,104,136,192,0,240,38
300 data 24,177,251,105,1,145,251,72
310 data 152,160,0,113,251,168,104,209
320 data 251,208,19,224,1,208,15,72
330 data 152,160,0,56,241,251,168,104
340 data 24,144,216,24,144,173,152,160
350 data 0,56,241,251,168,72,160,0
360 data 177,251,168,200,177,251,160,1
370 data 209,251,240,32,104,168,200,152
380 data 72,169,0,145,251,104,160,0
390 data 209,251,240,4,168,24,144,238
400 data 162,0,138,168,177,251,168,177
410 data 251,24,144,199,104,96,72,138
420 data 72,152,72,162,0,160,0,152
430 data 72,104,168,200,152,72,138,24
440 data 113,251,105,1,160,0,113,251
450 data 113,251,168,177,251,32,210,255
460 data 104,72,160,0,113,251,168,177
470 data 251,232,56,233,1,208,250,160
480 data 0,104,72,209,251,208,210,169
490 data 13,32,210,255,104,104,168,104
500 data 170,104,96

Tale codice ha il notevole pregio di poter essere eseguito senza alcuna modifica su molte macchine di casa Commodore.

Che altro dire?

Anche a distanza di anni il Commodore 64 continua ad affascinare ed interessare tanti suoi fan, per cui non mi resta che augurare buona programmazione a tutti coloro che vorranno cimentarsi ancora una volta a realizzare programmi per quella che è stata, e resta, una macchina mitica!