Okay, I'm back. The best way to look at the two methods is to put them side by side (with a bonus TOS-in-a thrown in for good measure). In these methods, I am assuming 65c802/816 in full 16-bit register mode, SP is in x, decrement before push, increment after pull, two address units per cell:
Code:
TOS in $0,x TOS in y TOS in a | 65m32 TOS in a
------------ ------------ ------------ | --------------
NOS in $2,x NOS in $0,x NOS in $0,x | NOS in $0,s
RSP in s RSP in s RSP in s | RSP in x (!!!)
This is how we init the stacks :
ldx #RP0 ldx #RP0 ldx #RP0 | ldx #RP0
txs txs txs | lds #SP0
ldx #SP0 ldx #SP0 ldx #SP0
This is how we DUP :
lda 0,x dex dex | pha
dex dex dex | $NEXT
dex sty 0,x sta 0,x
sta 0,x $NEXT $NEXT
$NEXT
This is how we DROP :
inx ldy 0,x lda 0,x | pla
inx inx inx | $NEXT
$NEXT inx inx
$NEXT $NEXT
This is how we OVER :
lda 2,x dex dex | pda ,s
dex dex dex | $NEXT
dex sty 0,x sta 0,x
sta 0,x ldy 4,x lda 4,x
$NEXT $NEXT $NEXT
This is how we SWAP :
lda 0,x lda 0,x ldy 0,x | exa ,s
ldy 2,x sty 0,x sta 0,x | $NEXT
sta 2,x tay tya
sty 0,x $NEXT $NEXT
$NEXT
This is how we NIP :
lda 0,x inx inx | ins
inx inx inx | $NEXT
inx $NEXT $NEXT
sta 0,x
$NEXT
This is how we @ :
lda (0,x) lda 00,y tay | lda ,a
sta 0,x tay lda 00,y | $NEXT
$NEXT $NEXT $NEXT
This is how we ! :
lda 2,x lda 0,x tay | sla #,b
sta (0,x) sta 00,y lda 0,x | sla ,b
inx inx sta 00,y | $NEXT
inx inx inx
inx ldy 0,x inx
inx inx lda 0,x
$NEXT inx inx
$NEXT inx
$NEXT
This is how we + :
lda 0,x tya clc | add ,s+
inx clc adc 0,x | $NEXT
inx adc 0,x inx
clc tay inx
adc 0,x inx $NEXT
sta 0,x inx
$NEXT $NEXT
This is how we - :
lda 2,x tya eor #$ffff | sub ,s+
sec eor #$ffff sec | cdd #1
sbc 0,x sec adc 0,x | $NEXT
inx adc 0,x inx
inx tay inx
sta 0,x inx $NEXT
$NEXT inx
$NEXT
This is how we >R :
lda 0,x phy pha | sla ,-x
inx ldy 0,x lda 0,x | $NEXT
inx inx inx
pha inx inx
$NEXT $NEXT $NEXT
This is how we R> :
pla dex dex | pda ,x+
dex dex dex | $NEXT
dex sty 0,x sta 0,x
sta 0,x ply pla
$NEXT $NEXT $NEXT
This is how we TUCK :
lda 0,x lda 0,x ldy 0,x | exa ,s
ldy 2,x sty 0,x sta 0,x | pda ,s
sta 2,x dex dex | $NEXT
sty 0,x dex dex
dex sta 0,x sty 0,x
dex $NEXT $NEXT
sta 0,x
$NEXT
This is how we PICK :
txa phx phx | add #,s
asl 0,x tya asl | lda ,a
adc 0,x asl adc 1,s | $NEXT
tay adc 1,s tax
lda 02,y tax lda 0,x
sta 0,x ldy 0,x plx
$NEXT plx $NEXT
$NEXT
This is how we DEPTH :
txa txa dex | pda #-1,s
eor #$ffff eor #$ffff dex | cdd #SP0
sec sec sta 0,x | $NEXT
adc #SP0 adc #SP0 txa
lsr lsr eor #$ffff
dex dex sec
dex dex adc #SP0-2
sta 0,x sty 0,x lsr
$NEXT tay $NEXT
$NEXT
The only clear winner for TOS in $0,x is DROP, which is in all fairness a very commonly executed word [Edit: ! (store) is also a winner for TOS in RAM]. The other two methods tie or edge it out in machine code size and execution speed for almost everything else, though.
Regarding
DEPTH ... you'll notice that it doesn't matter whether x is pointing to TOS or NOS; if (x == SP0), then the stack is empty, and if (x == SP0-2) then the stack contains one cell. The reason for this is that every word (like DUP ) which grows the stack does DEX DEX somewhere inside it, and every word (like DROP ) which shrinks the stack does INX INX somewhere inside.
The strange
#SP0-2 in the TOS-in-a version of DEPTH is there to counteract the necessity of performing the machine language equivalent of DUP before trashing the accumulator for the depth calculation. If the stack was empty and DEPTH was called, the DUP would have pushed nonsense, but that's not a problem, as long as the nonsense doesn't enter into the calculation. In fact, it doesn't matter which of the three methods you use; if you DUP an empty stack you're DUPing nonsense. It's just bad luck that TOS-in-a has to DEX DEX before the TXA to maintain non-empty stack integrity, that's all.
Let's look at a specific example:
SP0 = 9
x = 9
a = 1234
The 1234 is just nonsense, but it doesn't matter:
Code:
dex \ x is now 8
dex \ x is now 7
sta 0,x \ $07 now contains 1234
txa \ a is now 7
eor #$ffff \ a is now -8
sec
adc #SP0-2 \ a is now -8+1+9-2 = 0
lsr \ a is still 0, which is the correct depth
So for the TOS-in-register methods, as long as you always remember that x points to
NOS instead of
TOS, it doesn't matter if either or both of them contain uninitialized nonsense, as long as you don't try to use the uninitialized nonsense by allowing x to increment above SP0.
Hope this helps,
Mike B.
[Edit: Added in a column for my 65m32, with a hard line to separate fact from fantasy. Maybe I'll break through this year ...]
[Edit #2: Added code samples for >R R> TUCK and PICK ; fixed ! ]
Login
Register
FAQ
Search
