I was looking through starfox when I saw some code that used DJNZ in an unconventional way, this made me think about how useful it is, so here are some things I just thought of.

On this first one, you're going to say, "well duh," but I bet you don't do it.

Let's say you want to see if A==1:
dec a
jr nz, AWasnt1

You could replace it with this for only 1 extra t-state:
ld b, a
djnz AWasnt1

One benefit of this is that you don't destroy A. Now before you start complaining about that 1 t-state, just remember, if you manage to put your result into B rather than A, this routine becomes 3 t-states faster.


Here is another common code structure that I run into a lot:
ld a, (hl)
dec a
jr nz, not1
...
jr final
not1:
dec a
jr nz, not2
...
jr final
not2:
dec a
jr nz, not3
...
jr final
not3:
dec a
jr nz, not4
...
jr final
not4:
...
final:

Why not replace it with this, which is both faster and smaller (you don't need the jumps if you can leave b at 0):
ld b, (hl)
djnz not1
...
not1:
djnz not2
...
not2:
djnz not3
...
not3:
djnz not4
...
not4:
djnz not5
...
not5:

final:


Finally, this one is a bit more of a stretch, but you can use B as a flag byte, take for instance this byte plotter:
;######################################
;plot a byte
;a = byte
;b = inverse 1 = yes, 0 = no
;de = xy

plotAByte:
ld c, d
ld d, 0
ld h, d
ld l, e
add hl, de
add hl, de
add hl, hl
add hl, hl
srl c
srl c
srl c
ld e, c
add hl, de
ld de, plotSScreen
add hl, de

djnz inversing

or (hl)
ld (hl), a
ret

inversing:
cpl
and (hl)
ld (hl), a
ret


Also, while it's not a new idea today, I have used DJNZ in weird ways before, I typically do it when unpacking bytes from storage. This routine is from zStart and pulls a name out of storage from 6 bytes to 8 bytes. I use B as a bit counter.

pop hl
ld ix, op1+1
ld bc, 8*256+6
ld d, 8
xor a
unpackNameLoop:
rr (hl)
rra
djnz notNextUnpackByte
inc hl
ld b, 8
notNextUnpackByte:
dec c
jr nz, unpackNameLoop
ld c, 6
rra
rra
ld (ix), a
inc ix
xor a
dec d
jr nz, unpackNameLoop


Why not replace it with this, which is both faster and smaller (you don't need the jumps if you can leave b at 0):

Code: [Select]

ld b, (hl)
djnz not1
...
not1:
djnz not2
...
not2:
djnz not3
...
not3:
djnz not4
...
not4:
djnz not5
...
not5:

final:


Wow!  That's great stuff!  
Plus you can keep your original value unchanged in A.  

Another DJNZ hack is that you can use DJNZ $+2 to decrease B without affecting any flags. It's 4-9 cycles slower than normal DEC B, though.

It is one of those things that may not be used for a long time, but when it happens, somebody is going to feel special

It's amazing how creative you all are. For the djnz list i usually just use a jump table and maybe push a return value onto the stack, but that looks like it'd be smaller (if not faster), though you'd have to be careful with 'b'.

I think the best DJNZ is to ONLY use DJNZ I was reading about Single Instruction Set Computers and learned that using only DJNZ you can produce a turring complete language!

What does turring complete language mean? especially the turring part.
Do you mean Turing, as for example, the Turing test?