6502.org

Proxy, you were asked which bytes you were running. If you showed us the output of your assembler, then we'd all know exactly what code the 6502 is running. But with your own assembler, with your own syntax and your own understanding of the 6502 instruction set, there are too many variables.

yes it doesn't have indirect stuff, but () is still used to describe a regular absolute adress.
now you confused me.
LD A, [0x88] assembles to A5 88 (Zero Page)
LD A, (0x88)assembles to AD 88 00 (Absolute)
Yes kinda... i was just splitting up the indirect load into it's components to make it more visible why and how the brackets work in there.
and a regular indirect load works by:
1. loading immedaite value
2. use that as address for the Zero Page to load 2 values from
3. use those values as an Absolute address to load the final value into the A Register

all 3 steps together make up the Indirect load, but if you seperate them out like this you can see that it's just 3 other addressing modes working together.
that was my whole point, sorry if it was confusing.
yea, no. as said i'm used to how the Z80 does things, which is why i use it's snytax here too.
but as said before i take my time to convert the code before posting parts of it here.
but also as said i could get rid of the [] for Zero page stuff. so the convertion is a bit more linear.
LDA #0x80 -> LD A, 0x80
LDA 0x8000 -> LD A, (0x8000)
LDA (0x80) -> LD A, ((0x80)) or LD A, ([0x80])
oh right, i never thought of that, HAHA. 1 point for the Z80!
I'm sorry, i'm just used to doing things my own way, which gets in the way of asking for help.
also you guys are able to just read 6502 Binary?

also i tried to use a Disassembler so i can easily convert my code easily and accurately, but the only one i was able to find only supports the normal 6502 and not the 65C02....
if any of you could recommend a dissassembler for the 65C02, it would be really amazing.

Here's a reliable one: https://www.white-flame.com/wfdis/

Well, you can do that if you like, meaning that zero-page indirect will be LD A,([0x88]) and absolute indirect will be LD A,((0x88)), but I've never seen a 6502 assembler that uses brackets of any kind for zero-page addressing.

Typically zero-page addressing is not specified by the programmer in assembly code: the assembler decides whether to use zero-page or absolute depending on whether the address is in the $0000-$00FF range or not. Many assemblers don't even provide a way of explicitly specifying zero-page addressing. (I've just checked both the original MOS programming guide and the WDC 65816 book, and neither specifies one. Nor is one specified in the Apple EDASM or Merlin documentation.) Ways I've seen of explicitly specifying zero page addressing include:

• Macroassembler AS v1.32 and later: "<" prefix, e.g., LDA <addr.
• Macroassembler AS v1.31 and earlier: ".z" suffix, e.g., LDA addr.z.
• ASxxxx: "*" prefix, e.g. LDA *addr.

Only for a zero-page indirect load. That's all you have on the 6502, of course, but the 65C02 also has indexed absolute indirect addressing, e.g., LDA ($1234,X) or LDA ($1234),Y (in standard 6502 syntax).
Remember, you also need to convert code going back the other way: any time you use code from somewhere else, you need to change LDA ($20),Y to LDA (($20),Y). Were I trying to do that, I'm sure I'd be making subtle errors all over the place, since both are valid, but have different meanings. (The translation is slightly different if you use square brackets for indirection and parentheses for absolute addressing, but the confusion is still there. I think. I'm now confused even about what's confusing! :-))
Of course! Assemblers and disassemblers are only for the weak! :-) (And yes, I guess if we all write only machine-language code in this thread that will solve the problem handily. :-))

that seems promising. only downside it doesn't seem to be able to show bytes as ASCII.
also one thing i discovered, i can use my assembler to generate annotated binary files.
for example: though the other disassembler is still better at that. (can't copy the addresses though, there doesn't seem to be an option to copy the whole thing or just a selection)
only thing i personally don't like about it is that it has the audacity to use lowercase characters for the HEX and the Instructions.
anyways i'll be sure to use this to convert my code.
the ironic part is that for the normal 6502 syntax for this assembler i did program it like that to automically switch between both types, but for the Z80 Style syntax i didn't... i really think i should change that
wait the 65c02 has that? what is the OPcode? i don't think i have that in my assembler... i only got the 3 different zero page indirects (normal, X offset, and Y offset)
That's why i'm asking the creator of the CustomASM to maybe add an disassembler. so i can easily convert back and forth.
well i guess if you use the same opcodes for multiple decades you just get used to it.

And this promptly became a problem when the 65816 arrived, with its DBR and DPR registers which can make any 8-bit address refer to different locations in Direct Page (replacing Zero Page), Absolute, and Long addressing modes (which take up 8, 16 and 24 bits of operand respectively). You really do need to explicitly specify which addressing mode you mean on the '816, but continuing the traditional 6502 assembly syntax does not make that easy.

A while ago, I proposed a revised syntax to address precisely this problem, which did indeed use brackets in a broadly similar way to some other assembly syntaxes. I adopted [] for long addressing, () for absolute, and {} for Direct Page. I also suggested a method to verify that the M and X bits were being set consistently with what the assembler expected operand sizes to be. But I see no pressing reason to use this new syntax on the 6502 family itself, only on the '816 - and in any case I got distracted while trying to implement it.

The new opcodes for the new addressing modes are given on page 10 of the Rockwell R65C02 datasheet. LDA absolute indirect is $B2. But actually, absolute indirect isn't a completely new addressing mode; the original 6502 has it for JMP. (The 65C02 adds absolute indexed indirect for JMP: JMP ($1234,X).)

For first learning about the details of the new 65C02 features, it's probably easier to read Roger Wagner's "Assembly Lines," part 33 (June 1983 Softalk) than it is the data sheet.
For other systems that have a movable direct page (such as the 6809) this is generally dealt with by having an "assume" directive that allows you to tell the assembler what the current value of the DP register will be when that code executes, so that it can continue to do automatic determination of which form to use. (This doesn't actually have to be the actual value of the register, of course; if the DP is essentially a parameter into the routine, you can just assume it to be whatever pae, otherwise unused by you, is convenient and use that page for all DP accesses.)
This seems to me as if it may introduce the same kind of awkwardness as happened with Proxy's notation, where brackets of various sorts get overloaded. (E.g., how do you distinguish between an absolute and an absolute indirect access for those instructions that have both? Or even if the 65816 has no instructions that have both, you still have to remember that sometimes ($1234) is direct and sometimes indirect, depending on the instruction, don't you?)

Neither of those is a valid 65C02 instruction. The only valid absolute indirect instructions are JMP (<addr>) and JMP (<addr>,X). The valid 65C02 page zero indirect addressing modes are (<zp>), (<zp>,X) and (<zp>),Y. The 65C816 adds [<dp>] and [<dp>],Y, both being 24-bit indirect, i.e., <dp> is three contiguous bytes on direct (zero) page. If .Y is set to 16 bits, the [<dp>],Y mode can "touch" all 16 MB of address space with very succinct code.
Even better is to get a copy of the Eyes and Lichty manual, which covers all supported instructions in considerable detail and it does a good job of teaching the reader about 6502 assembly language in general, especially 6502 "idioms."
I'm not seeing a problem. Taking DP (direct page pointer) first, what that merely does is tell the '816 which part of bank $00 memory is direct page. Direct page instructions do not change. For example, LDA [$21] works the same no matter where DP points. All that changes is if DP is pointing to an absolute address the physical zero page is no longer accessible using eight-bit operands. If DP is set to $8400 and the instruction LDA $00 is executed, the effective address will be $8400, not $0000. If it is desired to access the real zero page 16-bit operands must be used. Complementary to that is an instruction such as LDA ($00) will effectively be LDA ($8400). This characteristic of the '816 makes it practical (and very useful) to point DP at some part of the stack and use direct page instructions to access a stack frame.

Turning to DB (data bank register), its content matters when 16-bit addresses are used in load/store instructions. It's important to understand that the '816 always generates 24-bit addresses, regardless of the addressing mode used. If an absolute addressing mode is specified for any load/store instruction DB will be prepended to the effective address to create the 24-bit address that the '816 will emit. DB will be ignored if the addressing mode is direct page, any of the direct page indirect long modes, or any of the absolute long modes. A load immediate instruction is always from the bank in which the instruction is located.
Why make it so complicated? You'd be better served by learning and using standard 6502 assembly language instead of trying to somehow make a 6502 program look like a Z80 program. It will also make it a lot easier for most of us to help you as you write software and run into trouble.

I might as well at this point, it's just there are some oddities with the names that make no sense to me.

like why is exclusive OR called "EOR" instead of "XOR" like literally any person calls it?
and don't come with the "but the first letter of 'Exclusive' is an 'E'" excuse. because then explain "Overflow" being shortent to a "V" instead of an "O" like the first letter is.

or why is Shifting to left "arithmetic" while shifting right is "logical"? it could just be left out without impacting anything.
why not just call them "Shift left" and "Shirt right" to better fit the "Rorate left" and "Rotate right" instruction names for consistency?
which also means that both instructions would then have consistent sounding instruction mnemonics like "ROL" and "ROR", those being "SFL" and "SFR".

another inconsistency is... some of the branch instructions.
half of them use the "branch on x set/clear" while the other half just uses a completely different way of naming them.
why not make them all have a consistent instruction mnemonic?

"Branch on Carry Clear" (BCC)
"Branch on Carry Set" (BCS)
"Branch on Overflow Clear" (BVC)
"Branch on Overflow Set" (BVS)

so these would need to change:

"Branch on Not Equal" (BNE) -> "Branch Zero Clear" (BZC)
"Branch on Equal" (BEQ) -> "Branch Zero Set" (BZS)
"Branch on Plus" (BRP) -> "Branch Negative Clear" (BNC)
"Branch on Minus" (BMI) -> "Branch Negative Set" (BNS)

and lastly the "Test and Reset memory bit" (TRB) and "Reset Memory Bit" (RMB) instructions are the only instructions that uses the word "Reset" instead of "Clear" like the rest of the Instructions do.
so technically they should be called "Test and Clear memory bit" (TCB) and "Clear Memory Bit" (CMB).

and then there also was the minor inconsistency where any Jump and Branch should technically use an immediate value. for example JMP #0x8000 instead of JMP 0x8000

but that kinda gets in the way of labels so i can understand that one i guess.

if those would've been different i would've used the 65c02 syntax from the start. but sadly i'm around 45 years too late to change these names or suggest changing them.

I see your point, but, much like English spelling, this is where we are. It's easy enough to get used to.

For my part, I find quite a barrier swapping between those machines where you say
op src dst
and those where you say
op dst src

But again, just like bilingualism, or driving on the wrong side, it's possible to switch.

but the Jump immediate makes sense, because it loads that immediate data directly into the Register, it doesn't use it as as address.
like CJS said you could imagine a Jump as a "Load PC" instruction, which makes it easier to understand.
LDA #0x80 would load the value "0x80" into the A Register.
and
LDA 0x8000 would use 0x8000 as an address to load a value that then gets loaded into the A Register
so following the same logic
LDPC #0x8000 or JMP #0x8000 would load the immediate value "0x8000" into the PC.
while
LDPC 0x8000 or JMP 0x8000 would use the immediate value "0x8000" as an address to load 2 bytes from which then get loaded into the PC.

now it would be consistent with the other instructions. but i guess jumps are just "special" load instructions that require different ways of refering to thier data compared to any other instruction... it's weird.

.

anyways i think it kinda got out of hand with confusing instruction mnemonics, non-sensical inconsistencies, etc.

(though one last thing, the Dissassembler i was shown before is kinda broken...? sometimes it just randomly stops disassembing, and for some reason it doesn't regonize "0x29" as an Instruction, but it should be an AND immediate)

so, i still need help with the ATF1504. as said i don't have a progammer for it and i don't really know how and which to choose.
plus i'm a bit confused by some of the pins as mentioned last time (around a billion posts ago)
this is around all i have currently for the breakout board.

Just about all of the 6502 assembly language comes from the MC6800, which given that both were designed by the same group of engineers, is not unexpected. Some of that language found its way into the MC68000 and then back into the 65C816—the latter inherited some instructions from the 68000, PEA being one of them.

You may be interested to know that at one time there was a proposal for an assembly language standard before the IEEE in which the 6800/6500 dialect would have been the prototype. The reason that dialect was considered was due to the uniform use of three-character mnemonics (very easy to encode in an assembler look-up table) and a generally unambiguous addressing mode notation, some of which harks back to the IBM mainframe assembly language of the 1960s. Unfortunately, competitors Intel and Zilog bickered over it and the proposal died.

BTW, at one time, I studied Zilog's horrid assembly language due my employer producing a product whose prototype powered by a Z80. To this day I still can't make heads or tails out of Z80 code. Mandarin Chinese would be less a challenge to understand.

Ditto. A jump is nothing more than an unconditional branch instruction.