Autore Topic: Print Using (Letto 5319 volte)

zimox · « **il:** 17 Novembre 2004, 19:08:14 »

un saluto
non avendo le necessarie capacita' in lm per poter programmare un comando del tipo print using "x.xx"
ho proceduto cosi' in basic sperando di non aver fatto una .........di codice

5 a=numero:a$=str$(a)
10 if a-int(a)=0 then a$=a$+".00"
oppure
10 fort=1to len(a$):if mid$(a$,t,1)<>"."then next t:a$=a$+".00"
poi
20 if mid$(a$,len(a$)-1,1)="."then a$=a$+"0"
non sempre va tutto bene perche' capita dopo moltiplicazioni multiple di trovarmi a=x.00000001... addio controlli
e sono insopportabilmente dispendiose e lente perche' sono all' interno di for next con matrici

si puo' fare qualcosa di piu' efficiente?
saluti e finalmente dopo un po' sono ancora tra voi

zimox

Alberto · « **Risposta #1 il:** 18 Novembre 2004, 18:25:28 »

Ciao

Citazione

ho proceduto cosi' in basic

Il problema è che per implementare una nuova istruzione serve modificare la rom del computer che gestisce l'istruzione PRINT in modo che tutte le volte che digiti
un'istruzione del tipo

PRINT USING "$[formato]",%[valore]

Il C64 esamini il parametro [formato],quindi il parametro [valore],e lo stampi di conseguenza;per questo serve l'assembler.

Senza toccare la rom del Basic,puoi usare un programmino di questo genere:

Codice: [Seleziona]

;*** SEMPLICE EMULAZIONE DI UNA PRINT USING ***

; USO DA BASIC: SYS 49152,formato,valore
; ESEMPIO:

; SYS 49152,X.XXX,3

; 3.000
; READY.

* = $c000

        lda #$2e
        jsr param  ; calcola il n.di cifre prima di .
        stx $fb
        lda #$2c
        jsr param  ; calcola il n.di cifre dopo .
        stx $fc    
skip    lda #$00
        jsr param
        sec
        cpx $fb      
        beq ok
        bcc ok 
        jmp $b248  ; errore di formato
ok      beq print
fill    lda #$30
        jsr $ffd2
        dec $fb
        cpx $fb
        bne fill    ; riempie la parte intera con gli zeri
print   sec
        lda $7a
        sbc $fb
        sta $7a
        ldy #$00
go      lda ($7a),y
        jsr $ffd2
        iny
        cpy $fb
        bne go
        lda #$2e
        jsr $ffd2  ; stampa .
loop    dec $fc
        bmi exit
        lda #$30
        jsr $ffd2
        jmp loop    ; stampa gli zeri finali
exit    jmp $a474  ; torna al prompt

param   sta $02
        ldx #$ff    ; inizializza contatore per le cifre prima di .
        ldy #$00
read    lda ($7a),y; legge il carattere attuale
        cmp $02    ; se è . esce
        beq ret
        inx        ; incrementa puntatore
        inc $7a    ; incrementa puntatore al carattere 
        bne cont
        inc $7b
cont    jmp read
ret     rts

Alberto · « **Risposta #2 il:** 18 Novembre 2004, 21:47:00 »

Qualcosa di meglio.Questa routine supporta anche i numeri con parte frazionaria non nulla.

Codice: [Seleziona]

;*** SEMPLICE EMULAZIONE DI UNA PRINT USING ***

; USO DA BASIC: SYS 49152,formato,valore
; ESEMPIO:

; SYS 49152,X.XXX,3.5

; 3.500
; READY.

* = $c000

        lda #$2e
        jsr param    
        stx $fb     ; salva n.cifre da rappresentare (parte intera)
        lda #$2c      
        jsr param    
        sta $02
        inc $02
        stx $fc     ; salva n.cifre da rappr.(parte frazionaria) + spiazzamento           
        lda #$2e
        jsr param
        sta $03
        inc $03
        stx $fd     ; calcola n.di cifre parte intera + spiazzamento
        lda #$00
        jsr param
        stx $fe
        lda $fc
        cmp $fe      
        bcc error    
        lda $fb
        cmp $fd
        bcc error    
        beq ok
        ldx $fb
        jsr fill       
ok      ldx $02
        lda #$2e
        sta $ff
        jsr print   ; scrive la parte intera        
        lda #$2e
        jsr $ffd2   ; scrive .
        ldx $03
        lda #$00
        sta $ff
        jsr print
fill2   lda $fe
        cmp $fc
        beq exit
        ldx $fc
        sta $fd
        jsr fill
exit    jmp $a474   ; torna al prompt

print   lda $0200,x   
        cmp $ff
        beq done
        jsr $ffd2   ; scrive la parte intera
        inx
        jmp print
done    rts

fill    lda #$30
        jsr $ffd2
        dex
        cpx $fd
        bne fill    ; riempie di zeri la parte intera e frazionaria
        rts

error   jmp $b248   ; errore di formato

param   sta $0313
        ldx #$ff    ; inizializza contatore per le cifre prima di .
        ldy #$00
read    lda ($7a),y ; legge il carattere attuale
        cmp $0313   ; se è il simbolo cercato,esce
        beq ret
        inx         ; incrementa puntatore
        inc $7a     ; incrementa puntatore al carattere 
        bne cont
        inc $7b
cont    jmp read
ret     lda $7a
        rts

zimox · « **Risposta #3 il:** 19 Novembre 2004, 18:54:02 »

ciao Alberto

ti ringrazio per la routine

anche la sys come comando e' perfetta per lo scopo

provero' ad implementarla con linee data in testa al programmino basic che ho fatto

saluti

iAN CooG · « **Risposta #4 il:** 20 Novembre 2004, 21:04:39 »

Codice: [Seleziona]

print   lda $0200,x

In questo modo funziona solo da immediate mode, e non da programma. Bisognerebbe stabilire in testa alla funzione un puntatore copiando $7a-$7b in un puntatore utility e usare quello. Ho tentato di modificarlo ma anche cosi' non va "sempre" bene, perche' puo' trovare le stringhe da leggere a cavallo di 2 pagine.

Codice: [Seleziona]

        * = $c000

        lda #0
        sta $22; $22-23 ptr buffer ($0200 imm. mode o indir. prg basic)
        lda $7b
        sta $23

        lda #$2e
        jsr param
        stx $fb  ; salva n.cifre da rappresentare (parte intera)
        lda #$2c
        jsr param
        sta $02
        inc $02
        stx $fc  ; salva n.cifre da rappr.(parte frazionaria) + spiazzamento

inc1

        lda #$2e
        jsr param
        sta $03
        inc $03
        stx $fd  ; calcola n.di cifre parte intera + spiazzamento
        lda #$00
        jsr param
        stx $fe
        lda $fc
        cmp $fe
        bcc error
        lda $fb
        cmp $fd
        bcc error
        beq ok
        ldx $fb
        jsr fill
ok      ldy $02
        lda #$2e
        sta $ff
        jsr print; scrive la parte intera
        lda #$2e
        jsr $ffd2; scrive .
        ldy $03
        lda #$00
        sta $ff
        jsr print
fill2   lda $fe
        cmp $fc
        beq exit
        ldx $fc
        sta $fd
        jsr fill
exit    rts        ;jmp $a474; torna al prompt

print   lda ($22),y
        cmp $ff
        beq done
        cmp #$3a  ;":"
        beq done
        jsr $ffd2; scrive la parte intera
        iny
        jmp print
done    rts

fill    lda #$30
        jsr $ffd2
        dex
        cpx $fd
        bne fill  ; riempie di zeri la parte intera e frazionaria
        rts

error   jmp $b248; errore di formato

param   sta $0313
        ldx #$ff  ; inizializza contatore per le cifre prima di .
        ldy #$00
read    lda ($7a),y; legge il carattere attuale
        cmp $0313; se è il simbolo cercato,esce
        beq ret
        cmp #$3a  ;":"
        beq ret
        inx        ; incrementa puntatore
        inc $7a    ; incrementa puntatore al carattere
        bne cont
        inc $7b
cont    jmp read
ret     lda $7a
        rts

Infatti se si prova un prg del genere

Codice: [Seleziona]

start tok64 testprtu.prg
0 dv=peek(186)
1 SYS57812"prtusing.prg",dv,0:POKE780,0:POKE781,0:POKE782,192:SYS65493
10 print"test print using"
11 print"test print using"
12 print"test print using"
13 print"test print using"
14 print"test print using"
15 print"test print using"
16 print"test print using"
17 print"test print using"
18 print"test print using"
19 print"test print using"
20 print"test print using"
21 print"test print using"
22 print"test print using"
23 print"test print using"
100 print "123.4 using xxx.xxx=";:sys49152,XXX.XXX,123.4:print" ok"
110 print "23.41 using xxx.xxx=";:sys49152,XXX.XXX,23.41:print" ok"
stop tok64

si vedra' che la riga 110 stampera' del garbage, mentre eliminando la riga 23 funziona.
Bisogna anche tenere conto che si potrebbe voler stampare una variabile e non un valore immediato.

Alberto · « **Risposta #5 il:** 25 Novembre 2004, 11:44:28 »

Citazione

Bisogna anche tenere conto che si potrebbe voler stampare una variabile e non un valore immediato.

E' vero:non ci avevo pensato :huh:
Mò vedo se riesco a scrivere qualcosa che risolva il problema del garbage e funzioni con le variabili...

Bye

Alberto · « **Risposta #6 il:** 25 Novembre 2004, 23:48:41 »

Ok,sono riuscito ad agganciarmi ad alcune routine del sistema operativo:adesso è possibile usare l'istruzione con variabili inserite in un programma Basic.
Non ho ancora testato il problema del garbage,domani vedrò che si può fare.
Ciauz

Codice: [Seleziona]

; PRINT USING MIGLIORATA USANDO ALCUNE ROUTINE DEL SISTEMA OPERATIVO
;
; USO
;
; SYS 49152,formato,[valore/variabile]
;

* = $c000

textchar = $0073
illegal = $b248
getvar = $af28
convert = $bddd

      ldx #$00
      ldy #$00
      stx $fb
      sty $fc
      stx $fd
      sty $fe
      stx $02
l1    jsr textchar
      cmp #$2e           ; "."
      beq l2
      inx
      jmp l1
l2    jsr textchar
      cmp #$2c           ; ","
      beq l3
      iny
      jmp l2
l3    lda $7a
      sta $fd
      lda $7b
      sta $fe
      jsr textchar
      beq flag           ; fine riga
      cmp #$2e           ; "."
      beq l4
      cmp #$3a           ; fine istruzione
      beq flag
      cmp #$30           ; carattere non valido
      bcc error
      cmp #$41           ; variabile
      bcs var
      inc $fb
      jmp l3+8
flag  inc $02            ; flag indicatore di un numero intero
l4    cpx $fb
      bcs l5
error jmp illegal
      
l5    lda $02
      bne l6
      jsr textchar
      beq l6
      cmp #$3a
      beq l6      
      inc $fc
      jmp l5
l6    cpy $fc
      bcs cont
      jmp error 
cont  cpx $fb
      beq print
      jsr fill
print clc
      lda $fb
      adc $fc
      sta $fb
      inc $fb
      inc $fb
      tya
      pha
      ldy #$01
      lda ($fd),y        ; stampa il numero
      cmp #$3a
      beq chk
      jsr $ffd2
      iny
      cpy $fb
      bne print+15
chk   lda $02
      beq skp            ; stampa "." solo per i numeri decimali
      lda #$2e
      jsr $ffd2
skp   pla
      tax
      cpx $fc
      beq ret
      lda $fc
      sta $fb
      jsr fill     
ret   rts

fill  lda #$30           ; riempie di zeri
      jsr $ffd2
      dex
      cpx $fb
      bne fill+2
      rts

var   tya
      pha
      txa
      pha
      jsr getvar           ; risale all'indirizzo della variabile
      jsr convert          ; la converte in formato ASCII
      ldx #$00
      ldy #$00
count lda $0101,x
      beq exit1
      cmp #$2e
      beq exit1+2
      inx
      jmp count
exit1 inc $02              ; flag indicatore di un numero intero
      stx $fb
      pla
      cmp $fb
      bcs ok
      jmp illegal                 
ok    inx
      sta $fc
      lda $02
      bne exit2
      lda $0101,x           ; stampa il numero
      cmp #$00
      beq exit2
      inx
      iny
      jmp ok+3
exit2 sty $fd
      pla
      cmp $fd
      bcs ok2
      jmp illegal
ok2   sta $fe
cmpr  ldx $fc
      cpx $fb
      beq prnt2
      jsr fill
prnt2 ldx #$00
      lda $0101,x
      beq prnt3
      jsr $ffd2
      inx
      jmp prnt2+2 
prnt3 lda $02
      beq pass
      lda #$2e
      jsr $ffd2            ; stampa "." (per i numeri interi)    
pass  ldx $fe
      cpx $fd
      beq end
      lda $fd
      sta $fb
      jsr fill
end   rts

iAN CooG · « **Risposta #7 il:** 26 Novembre 2004, 00:20:49 »

Citazione da: "Alberto"

Ok,sono riuscito ad agganciarmi ad alcune routine del sistema operativo:adesso è possibile usare l'istruzione con variabili inserite in un programma Basic.
Non ho ancora testato il problema del garbage,domani vedrò che si può fare.

Complimenti per l'ottimo lavoro, funziona perfettamente, gia' provato anche nel caso che i parametri si trovino a cavallo tra le pagine, sia come var che come val. immediati

Alberto · « **Risposta #8 il:** 26 Novembre 2004, 11:34:01 »

Citazione

Complimenti per l'ottimo lavoro, funziona perfettamente

Grazie,meno male che nel Kernal c'era una routine bella bella per la conversione virgola mobile/ASCII,altrimenti sai che fatica scrivere una routine su misura... :doh:

C'era ancora un piccolo problema con i valori immediati e i : (risolto inserendo un flag di controllo).La versione modificata è nel post sopra.

P.S.:Se riscontrate ancora problemi,o qualcuno ha qualcosa di meglio (soprattutto, di più breve) da proporre,soluzioni alternative sono ben accette.

Bye

Alberto · « **Risposta #9 il:** 26 Novembre 2004, 23:37:03 »

Codice: [Seleziona]

; PRINT USING MIGLIORATA USANDO ALCUNE ROUTINE DEL SISTEMA
; OPERATIVO (CON SUPPORTO DEL TRONCAMENTO)
; USO
;
; SYS 49152,formato,[valore/variabile/espressione]


* = $c000

textchar = $0073
illegal = $b248
print = $aaa0
char = $ffd2
      
; COPIA LA ROM BASIC CAMBIANDO ALCUNI BYTE PER EVITARE LA PRINT
      
      lda $0313
      bne ready    ; controllo per la modifica del Basic
      inc $0313
      ldy #$00
      lda #$00
      sta $fb
      lda #$a0
      sta $fc
copy  lda ($fb),y
      sta ($fb),y
      iny
      bne copy
      inc $fc 
      lda $fc
      cmp #$c0
      bne copy
      lda #$4c
      ldx #$e5
      ldy #$aa
      sta $aad9
      stx $aada
      sty $aadb        ; modifica parte del Basic per evitare la stampa
      lda #$60        ; nel formato predefinito
      sta $ab29         
ready jsr switch      ; attiva la RAM sotto la ROM
      
      ldx #$00
      ldy #$00
      stx $02
l1    jsr textchar
      cmp #$2e          ; "."
      beq l2
      inx
      jmp l1
l2    stx $fb
      jsr textchar
      cmp #$2c          ; ","
      beq l3
      iny
      jmp l2
l3    sty $fd
      jsr textchar
      jsr print          ; valuta l'espressione e ne deposita 
                        ; il risultato sulla pila :))
      ldx #$00
scan1 lda $0101,x
      beq exit1
      cmp #$2e
      beq exit1+2
      inx
      jmp scan1 
exit1 inc $02
      cpx $fb            ; compara la parte intera del numero 
      bcc ok1            ; con quella da rappresentare
      beq ok1
      jsr switch
      jmp illegal
ok1   stx $fc
      lda $0100
      jsr char          ; stampa segno
      ldx $fb
      cpx $fc
      beq skip1
      jsr fill
skip1 ldx #$00
      lda $0101,x        ; stampa parte intera
      beq next
      cmp #$2e
      beq next
      jsr char
      inx
      jmp skip1+2
next  lda #$2e
      jsr char          ; stampa "."
      lda $02
      beq skip2
      ldx $fd
      ldy #$00
      sty $fc
      jsr fill          ; riempie di zeri fino alla fine
      jmp ret             
skip2 inx
      lda $0101,x
      beq check          ; finite le cifre decimali
      jsr char
      inx
      dec $fd            ; stampa la parte decimale (con il troncamento)
      bne skip2+1
check lda $fd            ; troncamento delle cifre decimali
      beq ret
      ldx $fd
      ldy #$00            
      sty $fc
      jsr fill          ; riempimento con zeri         
ret   lda #$0d
      jsr char          ; stampa l'invio dopo il numero
      jsr switch        ; riattiva la ROM
      rts

fill  lda #$30          ; riempie di zeri
      jsr char
      dex
      cpx $fc
      bne fill+2
      rts       

switch lda $01
       eor #$01
       sta $01
       rts

iAN CooG · « **Risposta #10 il:** 27 Novembre 2004, 20:50:27 »

Per migliorare le prestazioni di questa v3 bisognerebbe controllare se il basic e' gia' stato copiato e patchato ad esempio

Codice: [Seleziona]

    jsr switch
    ldx $aac2
    jsr switch 
    cpx #$ea
    beq inizio 
    
    (trasf basic)

    lda #$ea
patchloop 
    ldx #$05
    sta $aac2,x
    dex
    bpl patchloop 

inizio
(resto della routine)

Pero' occhio che questa versione con alcuni valori da' ?FORMULA TOO COMPLEX
ad esempio
1 sys49152,xxx.xxx,1.5
2 goto 1
prima o poi stampera' valori strani o l'errore.

Io intanto ho preso la tua V2 e l'ho ridotta di dimensioni. Ho usato pero' dasm come compilatore.

Codice: [Seleziona]

        org $c000

;Basic/Kernal routines
textchar    = $0073
illegal     = $b248
getvar      = $af28
convert     = $bddd
CHROUT      = $ffd2
;ZP variabili,5 bytes
zpcntr1     = $fb
zpcntr2     = zpcntr1+1
zpadd       = zpcntr1+2
zpflag      = zpcntr1+4

;---------------------------
        lda #0
        ldx #(zpflag-zpcntr1+1)
        tay
inix    sta zpcntr1-1,x
        dex
        bne inix
;---------------------------
l1      jsr textchar
        cmp #$2e     ; "."
        beq l2
        inx
        bne l1
l2      jsr textchar
        cmp #$2c     ; ","
        beq l3
        iny
        bne l2
l3      lda $7a
        sta zpadd
        lda $7b
        sta zpadd+1
l3p8    jsr textchar
        beq flag     ; fine riga
        cmp #$2e     ; "."
        beq l4
        cmp #$3a     ; fine istruzione
        beq flag
        cmp #$30     ; carattere non valido
        bcc error
        cmp #$41     ; variabile
        bcs var
;---------------------------
        inc zpcntr1
        bne l3p8
flag    inc zpflag      ; flag indicatore di un numero intero
l4      cpx zpcntr1
        bcc error

l5      lda zpflag
        bne l6
        jsr textchar
        beq l6
        cmp #$3a
        beq l6
        inc zpcntr2
        bne l5
l6      cpy zpcntr2
        bcc error
cont    cpx zpcntr1
        beq print
        jsr fill
print   clc
        lda zpcntr1
        adc zpcntr2
                    ;sta zpcntr1
        adc #$02    ;inc zpcntr1
        sta zpcntr1 ;inc zpcntr1

        tya
        pha
        ldy #$01
print15 lda (zpadd),y    ; stampa il numero
        cmp #$3a
        beq chk
        jsr CHROUT
        iny
        cpy zpcntr1
        bne print15
chk     lda zpflag
        beq skp      ; stampa "." solo per i numeri decimali
        lda #$2e
        jsr CHROUT
skp     pla
        tax
        cpx zpcntr2
        beq end
        lda zpcntr2
        sta zpcntr1
        jmp fill
;---------------------------
error   jmp illegal
;---------------------------
var     tya
        pha
        txa
        pha
        jsr getvar     ; risale all'indirizzo della variabile
        jsr convert     ; la converte in formato ASCII
       ;ldx #$00
       ;ldy #$00; a/x = 0 al ritorno da $bddd
        tay
count   lda $0101,x
        beq exit1
        cmp #$2e
        beq exit12
        inx
        bne count
;---------------------------
exit1   inc zpflag       ; flag indicatore di un numero intero
exit12  stx zpcntr1
        pla
        cmp zpcntr1
        bcc error
ok      inx
        sta zpcntr2
ok3     lda zpflag
        bne exit2
        lda $0101,x     ; stampa il numero
        beq exit2
        inx
        iny
        bne ok3
exit2   sty zpadd
        pla
        cmp zpadd
        bcc error
ok2     sta zpadd+1
cmpr    ldx zpcntr2
        cpx zpcntr1
        beq prnt2
        jsr fill
prnt2   ldx #$00
prnt22  lda $0101,x
        beq prnt3
        jsr CHROUT
        inx
        bne prnt22
prnt3   lda zpflag
        beq pass
        lda #$2e
        jsr CHROUT      ; stampa "." (per i numeri interi)
pass    ldx zpadd+1
        cpx zpadd
        beq end
        lda zpadd
        sta zpcntr1
;---------------------------
fill    lda #$30     ; riempie di zeri
fill2   jsr CHROUT
        dex
        cpx zpcntr1
        bne fill2
end     rts

iAN CooG · « **Risposta #11 il:** 27 Novembre 2004, 20:54:11 »

Ho anche messo QUA un rar con i sorgenti e d64 di prova

Alberto · « **Risposta #12 il:** 28 Novembre 2004, 14:38:26 »

Ok,vedo che si può fare per risolvere il ?FORMULA TOO COMPLEX.Proverò a togliere le parti della PRINT inutili.

Bye

zimox · « **Risposta #13 il:** 28 Novembre 2004, 18:22:37 »

Citazione da: "iAN CooG/HF"

Pero' occhio che questa versione con alcuni valori da' ?FORMULA TOO COMPLEX
ad esempio
1 sys49152,xxx.xxx,1.5
2 goto 1
prima o poi stampera' valori strani o l'errore.

un saluto
desidero ringraziare iAN e Alberto per l' interessamento...

pero ' a me e' da 20 minuti che sul mio c64c fa questo goto 1 ma tutto va alla perfezione ...anche cambiando il valore va tutto bene...meglio cosi'

zimox

modifica....
naturalmente intendevo la routine gia' bella e pronta di iAN

Alberto · « **Risposta #14 il:** 29 Novembre 2004, 12:06:29 »

Versione 3 corretta:risolto il problema del ?FORMULA TOO COMPLEX e inserito un semplice controllo per skippare la modifica del Basic quando non più necessaria.
Ciauz