Compilatori Basic

[Simokun]

 Ciao a tutti

Girovagando sul web ho trovato questa pagina interessante:
Commodore Languages List

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 si trova un misterioso "BLITZ BASIC COMPILER" e poco sotto un paio di compilatori per il C

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

[albman]

 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/  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

 

[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
- 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"...

[iAN CooG]

 

- 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

Codice: [Seleziona]

   * = $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.

Codice: [Seleziona]

;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.

[Simokun]

  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]

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 " nel senso che nemmeno ti mostrava (in apparenza) la SYS del programma compilato. Mica m'aspettavo il listato

[zimox]

 il "trucchetto" delle rem e delle password....
a suo tempo(tanto tempo fa) l' avevo aggirato semplicemente stampando su carta la linea  :D    :D