;####################################################################
;#
;# Speicherstellen fuer den Daten-Stack
;#
;####################################################################

 !addr stl = $5000
 !addr sth = $5001

 !addr stp = $0334


;####################################################################
;#
;# Verwendete BASIC- und Kernal-Routinen
;#
;####################################################################

 !addr locate_var = $b0e7    ; Basic-Variable ermitteln
 !addr umult = $b357         ; 16-Bit-Werte multiplizieren
 !addr print_line_no = $bdcd ; 16-Bit-Wert ausgeben
 !addr chrout = $ffd2        ; Zeichen ausgeben


; -- aus dem 64er Assembler-Sonderheft Seite 51 --

udiv
 ldx #0
 stx $5c         ; Rest
 stx $5d
 ldy #16         ; Durchgaenge
-
 asl $57
 rol $58
 rol $5c
 rol $5d
 sec
 lda $5c         ; $5c/$5d - $59/$5a
 sbc $59
 tax
 lda $5d
 sbc $5a
 bcc +           ; Ergebnis < 0
 stx $5c
 sta $5d
 inc $57
+
 dey
 bne -
 rts


;####################################################################
;#
;# Makros
;#
;####################################################################

; Stackpointer initialisieren

 !macro initstp {
   ldx #0
 }


; Stackpointer erhoehen

 !macro incstp {
   inx
   inx
 }


; Stackpointer verringern

 !macro decstp {
   dex
   dex
 }


; Wert auf dem Stack ablegen (high byte muss im
; Hardware-Stack und low byte im A-Reg liegen)
; ( -- w ), [ b -- ]

 !macro push {
   sta stl,x
   pla
   sta sth,x
   +incstp
 }


; Festen Wert (literal) auf dem Stack ablegen
; ( -- w ), [ -- ]

 !macro lit .val {
   lda #>.val
   pha
   lda #<.val
   +push
 }


; Wert TRUE (1) auf dem Stack ablegen
; ( -- 1 ), [ -- ]

 !macro true {
   lda #0
   pha
   lda #1
   +push
 }


; Wert FALSE (0) auf dem Stack ablegen
; ( -- 0 ), [ -- ]

 !macro false {
   lda #0
   pha
   lda #0
   +push
 }


; Wert vom Stack holen (low byte liegt im A-Reg,
; und high byte auf dem Hardware-Stack)
; ( w -- ), [ -- b ]

 !macro pop {
   +decstp
   lda sth,x
   pha
   lda stl,x
 }

; Wert vom Stack entfernen
; ( w -- )

 !macro drop {
   +decstp
 }


; Wert aus einer Adresse auf dem Stack ablegen
; ( -- w ), [ -- ]

 !macro lod adr {
   lda adr+1
   pha
   lda adr
   +push
 }


; Wert vom Stack holen und an einer Adresse ablegen
; ( w -- ), [ -- ]

 !macro sto adr {
   +pop
   sta adr
   pla
   sta adr+1
 }


; Bedingter Sprung bei false
; ( 0|1 -- ), [ -- ]

 !macro jpc adr {
   +pop
   bne +
   pla
   bne ++
   jmp adr
+
   pla
++
 }


; Namen fuer Basic-Integervariable auf dem Stack ablegen
; ( -- v ), [ -- ]

 !macro litv .c1, .c2 {
   lda #.c1
   ora #$80
   pha
   lda #.c2
   ora #$80
   +push
 }


;####################################################################
;#
;# Funktionen
;#
;####################################################################

; ( w -- w w )

dup
 +decstp
 lda stl,x
 sta stl+2,x
 lda sth,x
 sta sth+2,x
 +incstp
 +incstp
 rts


; ( w1 w2 -- w2 w1 )

swap
 +decstp
 +decstp
 lda stl,x
 pha
 lda stl+2,x
 sta stl,x
 pla
 sta stl+2,x
 lda sth,x
 pha
 lda sth+2,x
 sta sth,x
 pla
 sta sth+2,x
 +incstp
 +incstp
 rts


; ( w1 w2 -- w1+w2 )

add
 +decstp
 +decstp
 clc
 lda stl,x
 adc stl+2,x
 sta stl,x
 lda sth,x
 adc sth+2,x
 sta sth,x
 +incstp
 rts


; ( w1 w2 -- w1-w2 )

sub
 +decstp
 +decstp
 sec
 lda stl,x
 sbc stl+2,x
 sta stl,x
 lda sth,x
 sbc sth+2,x
 sta sth,x
 +incstp
 rts


; ( w1 w2 -- w1*w2 )

mul
 +pop            ; zweiten Wert vom Stack holen und fuer umult ablegen
 sta $71
 pla
 sta $72
 +pop            ; ersten Wert vom Stack holen und fuer umult ablegen
 sta $28
 pla
 sta $29
 stx stp         ; Stackpointer sichern
 jsr umult
 tya             ; high byte steht in Y, low byte in X
 pha
 txa
 ldx stp         ; Stackpointer wieder laden
 +push           ; Ergebnis auf dem Stack ablegen
 rts


; ( w1 w2 -- w1/w2 w1%w2 )

divmod
 +pop            ; zweiten Wert vom Stack holen und fuer udiv ablegen
 sta $59
 pla
 sta $5a
 +pop            ; ersten Wert vom Stack holen und fuer udiv ablegen
 sta $57
 pla
 sta $58
 stx stp         ; Stackpointer sichern
 jsr udiv
 ldx stp         ; Stackpointer wieder laden
 lda $58         ; Ergebnis auf dem Stack ablegen
 pha
 lda $57
 +push
 lda $5d         ; Rest auf dem Stack ablegen
 pha
 lda $5c
 +push
 rts


; ( w1 w2 -- w1/w2)

div
 jsr divmod
 +drop
 rts


; ( w1 w2 -- w1%w2)

mod
 jsr divmod
 jsr swap
 +drop
 rts


; ( w -- w+1 )

incr
 +decstp
 inc stl,x
 bne +
 inc sth,x
+
 +incstp
 rts


; ( w w -- 0|1 ), [ -- ]

eql
 +decstp
 +decstp
 lda stl,x
 cmp stl+2,x
 bne +
 lda sth,x
 cmp sth+2,x
 bne +
 +true
 rts
+
 +false
 rts


; ( w w -- 0|1 ), [ -- ]

neq
 +decstp
 +decstp
 lda stl,x
 cmp stl+2,x
 bne +
 lda sth,x
 cmp sth+2,x
 bne +
 +false
 rts
+
 +true
 rts


; ( w w -- 0|1 )

lss
 jsr sub
 bcc +           ; Ergebnis < 0
 +drop
 +false
 rts
+
 +drop
 +true
 rts


; ( w w -- 0|1 )

geq
 jsr sub
 bcs +           ; Ergebnis >= 0
 +drop
 +false
 rts
+
 +drop
 +true
 rts


; Dezimalwert ausgeben
; ( w -- )

outdec
 +pop
 stx stp         ; Stackpointer sichern
 tax             ; low byte nach X
 pla             ; high byte nach A
 jsr print_line_no
 ldx stp         ; Stackpointer wieder laden
 rts


; Zeichen ausgeben (nur das low byte wird beachtet)
; ( w -- )

outchr
 +pop
 stx stp         ; Stackpointer sichern
 tax             ; low byte sichern
 pla             ; high byte verwerfen
 txa             ; low byte wieder holen
 jsr chrout
 ldx stp         ; Stackpointer wieder laden
 rts


; Wert einer Basic-Integervariablen laden (Variablen in
; Basic werden in der Reihenfolge high/low gespeichert)
; ( v -- w )

lodint
 +pop
 sta $46         ; zweites Zeichen des Namens (low byte)
 pla
 sta $45         ; erstes Zeichen des Namens (high byte)
 stx stp         ; Stackpointer sichern
 jsr locate_var
 ldx stp         ; Stackpointer wieder laden
 ldy #0          ; high byte des Variablenwertes laden
 lda ($47),y
 pha
 iny             ; low byte des Variablenwertes laden
 lda ($47),y
 +push
 rts


; Wert in einer Basic-Integervariablen speichern (Variablen in
; Basic werden in der Reihenfolge high/low gespeichert)
; ( w v -- )

stoint
 +pop
 sta $46         ; zweites Zeichen des Namens (low byte)
 pla
 sta $45         ; erstes Zeichen des Namens (high byte)
 stx stp         ; Stackpointer sichern
 jsr locate_var
 ldx stp         ; Stackpointer wieder laden
 +pop
 ldy #1          ; low byte des Werts speichern
 sta ($47),y
 dey             ; high byte des Werts speichern
 pla
 sta ($47),y
 rts

You are viewing proxied material from sdfeu.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.