Ready64 Forum
Commodore 64 => Programmazione, Grafica e Musica => Topic aperto da: Simokun - 05 Gennaio 2006, 22:21:55
-
Ciao a tutti
Girovagando sul web ho trovato questa pagina interessante:
Commodore Languages List (http://www.npsnet.com/danf/cbm/languages.html)
Nella lista vengono menzionati alcuni compilatori per il BASIC del C64 (dei quali ignoravo del tutto l'esistenza); sfortunatamente tutti i link presenti sono inattivi e le ricerche con google non mi hanno aiutato poi molto çç
QUI (http://www.centsible.com/c64feat.shtml) si trova un misterioso "BLITZ BASIC COMPILER" e poco sotto un paio di compilatori per il C :o
Voi avete + notizie a riguardo? Come funziona questo BLITZ!?
esistono prodotti similari, magari free e se si... DOVE?
... la cosa mi ha incuriosito
grazie per l'aiuto
Saluti, Simokun
-
Ciao
io ti posso dire questo: su Radio Elettronica e Computer era uscito un compilatore basic funzionava in questo modo: scrivevi il tuo programmino sul C64, poi lanciavi il compilatore con un SYS xxxxxxx e lui compilava il programma in linguaggio macchina salvandolo su disco.
Io l'avevo provato a lungo e ti posso dire che la compilazione non era ottimale... piu' aumentavi la complessità del listato basic e piu' aumentavano le probabilità che il compilato si piantasse. Soprattutto lo metteva in crisi l'uso di molte variabili.
Puoi cercare tra i numeri di REC archiviati su edicola.64 se ti interessa....
guarda anche nella sezione TOOLS di http://www.haddewig.de/nogames64/ (http://www.haddewig.de/nogames64/) dove trovi
il Blitzcompiler che dici tu e anche un Basic 64 Compiler; non escludo che questultimo non sia lo stesso che a suo tempo trovai sulla cassetta allegata a REC
ciao
-
Del Blitz ricordo due cose:
- ad un programma da lui compilato se scrivevi LIST compariva BLITZ! e poi READY. In pratica ti prendeva per il :ciapet:
- esisteva un "antidecompilatore Blitz" pubblicato su CCC intorno al numero 29, 30, 31 o giù di lì (sicuro non prima del 29 e non dopo il 33). Se può aiutarti, era nelle ultime pagine.
Ricordo che in quelle pagine mi spaventava (beh era l'86, avevo 9 anni quando lo vidi la prima volta) il disegno (del disegnatore Dotto, se non sbaglio) che faceva vedere un tizio con un ghigno così :D che si avvicinava al computer, scriveva qualcosa sulla tastiera con un "EH EH" in mente e poi il computer esplodeva, bruciava, insomma si rompeva, da solo e lui (che non si vedeva quasi più coperto dal computer) continuava con il suo "EH EH"... :o
-
- esisteva un "antidecompilatore Blitz" pubblicato su CCC
Trovato, in fondo al numero 32.
Visto che era corto l'ho digitato, tralasciando il caricatore basic ma direttamente come linee byte e compilato con dasm
* = $c000
byte 169,000,133,251,169,009,133
byte 252,160,000,177,251,073,255
byte 145,251,200,208,247,230,252
byte 165,252,201,000,208,239,169
byte 146,141,029,008,169,012,141
byte 030,008,076,028,008,169,000
byte 133,251,168,169,009,133,252
byte 177,251,073,255,145,251,200
byte 208,247,230,252,165,252,197
byte 046,208,239,165,046,141,024
byte 192,230,045,208,002,230,046
byte 160,000,185,000,192,145,045
byte 200,192,040,208,246,234,165
byte 046,141,030,008,165,045,141
byte 029,008,024,105,040,144,002
byte 230,046,133,045,096
Ma siccome 'sti numeri non mi dicono nulla ho decompilato e commentato il file oggetto per capire come funzionava.
;antideblitz.prg
;decompilato e commentato da iAN CooG/HokutoForce
*= $C000
;--------------------------------------------------
; routine di decriptazione, appesa a fine programma
;--------------------------------------------------
DECR LDA #$00
STA $FB
; parte da $0900
LDA #$09
STA $FC
LDY #$00
x00A LDA ($FB),Y
; decripta (bytecorrente EOR $FF)
EOR #$FF
STA ($FB),Y
INY
BNE x00A
INC $FC
LDA $FC
; valore mod. dalla routine di criptazione
x017 CMP #$00
; raggiunta ultima pagina del prog?
BNE x00A
; ripristina la JMP iniziale con $0C92 perche'
; modificata dalla routine di criptazione.
LDA #$92
STA $081D
LDA #$0C
STA $081E
; Il programma ora e' decriptato e puo'
; ripartire normalmente
JMP $081C
;--------------------------------------------------
; routine di criptazione: SYS 49192
;--------------------------------------------------
CRIP LDA #$00
STA $FB
TAY
; parte da $0900
LDA #$09
STA $FC
x031 LDA ($FB),Y
; cripta (bytecorrente EOR $FF)
EOR #$FF
STA ($FB),Y
INY
BNE x031
INC $FC
LDA $FC
; byte alto fine prog?
CMP $2E
BNE x031
; cripta quindi solo da $0900 a $xx00
; lasciando fuori solo l'ultima pagina
; modifica la routine di decriptazione
; mettendo il valore corrente di $2e
LDA $2E
STA x017+1
INC $2D
BNE $C04D
INC $2E
x04D LDY #$00
; leggi la routine di decriptazione
x04F LDA DECR ,Y
; appendila a fine programma
STA ($2D),Y
INY
; lunga 40 bytes (C000-C027)
CPY #$28
BNE x04F
; cambia la JMP iniziale da $0C92 all'indirizzo
; della routine di decriptazione appena appesa
NOP
LDA $2E
STA $081E
LDA $2D
STA $081D
; aggiunge la lunghezza della rout. di decriptazione
; ai puntatori di fine programma $2d/$2e
CLC
ADC #$28
BCC x06B
INC $2E
x06B STA $2D
; siamo pronti per il SAVE"NUOVO PROGRAMMA",8
RTS
Idea carina, ma non certo efficace. O meglio, non e' efficace quanto un comunissimo compressore, che ha in piu' il pregio di ridurre anche la dimensione del programma, mentre questo lo fa aumentare, anche se solo di 40 bytes.
In entrambi i casi, chi vuole decompilarlo, non deve far altro che tracciare le routine di decompressione (o in questo caso di decriptazione) con un monitor e salvare la memoria appena prima di effettuare la JMP che fa ripartire il programma, a questo punto in chiaro.
-
:hail: Grazie albman per l'ottimo link che mi hai postato
Ho trovato un sacco di cose interessanti tra cui anche i compilatori
che stavo cercando; appena avro' un po' di tempo libero effettuero'
test piu' approfonditi compilando un po' di robetta...
Con il Blitz non dovrei avere particolari problemi in quanto
il programma chiede il nome del file che si desidera compilare
o meglio ancora con due unita' floppy e' possibile compilare tutto
cio' che si trova nel floppy 8 nel floppy 9 ;)
Il Basic64 Compiler invece viene caricato ed una volta eseguito
torna al classico "READY" e da li non so andare avanti...
servirebbe un po' + di documentazione çç
Cmq che sballo sta cosa !
Se avessi saputo all'eta' di 8 anni che era possibile
compilare ed ottimizzare i miei listati in Basic sul mio C64
avrei programmato roba + complessa anziche' la semplice
mongolfiera C= che svolazzava per lo schermo ;)
Massi cadenti:
Del Blitz ricordo due cose:
- ad un programma da lui compilato se scrivevi LIST compariva BLITZ! e poi READY. In pratica ti prendeva per il
Non credo che prendesse per il fondelli...
se il programma basic viene compilato non hai + modo
di listare il sorgente in quanto il codice ottenuto dovrebbe
essere in LM... senno' a che servirebbe un compilatore?
Sarebbe come aprire un file exe con un editor di testo
e sperare di avere il sorgente in C ;)
Saluti
Simokun
-
Massi cadenti:
Del Blitz ricordo due cose:
- ad un programma da lui compilato se scrivevi LIST compariva BLITZ! e poi READY. In pratica ti prendeva per il
Non credo che prendesse per il fondelli...
se il programma basic viene compilato non hai + modo
di listare il sorgente in quanto il codice ottenuto dovrebbe
essere in LM... senno' a che servirebbe un compilatore?
Sarebbe come aprire un file exe con un editor di testo
e sperare di avere il sorgente in C ;)
Sì ma ovviamente almeno una SYS doveva esserci. Ovviamente la SYS c'era e la scritta BLITZ! era scritta col trucchetto del REM" (*), ma all'epoca chi ci pensava ;)
(*) Per quei pochi (spero) che non lo conoscessero: il trucchetto del REM" consisteva nello scrivere a fine riga BASIC la seguente cosa, ad esempio:
10?"PIPPO":REM"
a questo punto bisogna battere in sequenza i tasti che indico tra parentesi tonde:
1) (virgolette)[per uscire dal modo virgolette]
2) (delete)[per cancellare le seconde virgolette]
3) (rvs on)[per entrare in modo reverse]
4) (lettera t)[per scrivere una T in reverse]
ripetere il punto 4 altre 19 volte, scrivendo in totale 20 T in reverse
5) (rvs off)[per uscire dal modo reverse]
6) (scrivere "blitz!" senza le virgolette)[per scrivere "blitz!" senza le virgolette]
la linea prima di premere return comparirà così:
10?"PIPPO":REM"§§§§§§§§§§§§§§§§§§§BLITZ!
dove § è la T in reverse
7) (tasto return)[per inserire la riga BASIC nella memoria]
Il risultato è che ad un successivo LIST compare la scritta BLITZ! o meglio, compare la linea che viene subito cancellata e sostituita dalla scritta BLITZ! . Ovviamente la linea è sempre lì al suo posto e lo dimostra il fatto che compare scrivendo LIST 10 .
Il numero di T in reverse dipende ovviamente dal numero di caratteri da cancellare (tenendo conto delle istruzioni "estese" e degli spazi che il BASIC inserisce di suo).
Il vero BLITZ! ovviamente cancellava una SYS che era l'inizio del programma vero e proprio.
Per tornare all'osservazione, "prendeva per il :ciapet:" nel senso che nemmeno ti mostrava (in apparenza) la SYS del programma compilato. Mica m'aspettavo il listato :)
-
il "trucchetto" delle rem e delle password....
a suo tempo(tanto tempo fa) l' avevo aggirato semplicemente stampando su carta la linea :D :mattsid: :D