6502.org

Hello all. I'm just sinking my teeth into 6502 and I thought a good idea for a simple starter program was to write one that could fill a screen. My various attempts failed because I'm an idiot and didn't know how to properly reference 16 bit addresses. So, I found a program that does what I was trying to do so I could try to reverse engineer it a bit, but it just left me with more questions. Here's the code I found: As I understand it, the X register being stored at $01 represents the first half of the 16 bit address being referenced, which is then combined(?) with the increasing Y value. Starting at $0200 and increasing with each loop until reaching the end of the vram at $05FF. However, I don't understand how this works. The indirect indexed reference is referencing $00, which stores nothing. Shouldn't it be ? And in draw_segment, there is a branch not equal instruction with no compare instruction before it? What is the branching condition?

All of this is probably very simple to anyone versed in machine languages, but that's why I'm in the newbies board. Try and go easy on me.

Will take the 16 bit address stored at $00 & $01 ($00 low byte, $01 high byte) and add the value of Y to that. The value in the Accumulator "A" register is then stored to memory at the resulting address.

The opcode will affect the Zero Flag in the status register so once Y goes from $FF to $00, the flag is set and the branch is not taken.

I think they are assuming the value of $00 to be $0 and storing $02 at $01 to make the effective start address $0200 + Y. The innner loop then fills all locations from $0200 to $02FF then increments $01 and repeats until it reaches $05FF.

Hope this helps!

Daryl

Ohh, that makes a lot more sense now, thank you! The syntax is just a bit confusing. Does it just use the next location in memory as the high byte and the referenced byte as the low one? If I were to shift addresses by one, and store the high byte in $02 and use would it have the same effect?

edit: also, yeah, documentation told me that branching runs on the Z flag, so it makes sense now that I know it's triggered by an overflow

This is an excellent newbie question. Many 6502 instructions set status flags automatically so you can test them without needing any compare instructions. In this common looping pattern: When .Y contains $FF, adding 1 to it will cause it to "wrap around" to 0. The iny instruction automatically sets the Z flag when this happens. So, this loop will do some stuff 256 times (.Y = 0 through 255). A good instruction set reference will tell you what flags an instruction affects.

The fact that the 6502 family handles instructions in this fashion is one of the reasons it produces good throughput at relatively sedate clock speeds.  Not having to do an explicit comparison each time a register or memory value is incremented/decremented can eliminate a lot of clock cycles out of a loop.

Yes. Your address pair is now in $01/$02.