I've looked and it's been a challenge to figure out which of the ii's to emulate for doing assembly on the apple ii. I like the enhanced iie, it's got fp basic, int basic, monitor and mini-assembler available on power up. But, I'm ignorant, really, just cuz i'm able to get it working doesn't mean it's ideal. I see lots of iic stuff out there. The list of emulated systems is quite long ii, ii+, iic, iic+, iie, iie enhanced, prolly others i've missed. Should i consider emulating iic over iie enhanced? What are y'alls experience with one vs the other?
Thanks,
Will
What assembler are you using?
So far, the Mini-Assembler, but I have Merlin, Merlin Pro, and ... That is to say, I have no idea, but all of these prolly work. So far, I'm getting the environment set up and ready. I've done some of the examples in Assembly Lines with Merlin and fiddled in the monitor and mini-assembler.
You should be good with the IIe and Merlin... especially just starting out it should make little difference. I would also urge you to look into cross compiling so you can just write the code with a modern editor. I liked Merlin back in the day, but I cross compile on my Linux machine now
I also do my editing and assembling on Linux. There is a Merlin32 which runs on Linux but I ended up writing my own assembler because I wanted something that was flexible enough to assemble code written for several different classic assemblers. Merlin is good, but a lot of code out there is written for LISA, EDASM, SC, etc.
Assembling on a modern machine is almost instantaneous and you can also assemble code in one chunk that would be way too big to do on vintage hardware.
The enhanced IIe and the IIc both have a 65c02, but one difference is that the IIe's disassembler isn't updated for the new opcodes, they show up as "???".
I agree with other comments you will wind up cross-assembling in the end, but it can be fun and useful to play with the vintage assemblers and appreciate the boundary conditions developers had to live with in the old days. The choice of emulator will likely affect your experience more than the choice of emulated machine.
If you are interested in testing a program that uses third party expansion cards then the IIc variants are out because they have no slots. Outside of that I don't know any big reason to prefer IIe or IIc either way as a development platform.
The IIc+ and IIgs are faster than the others, so if the emulator is using realistic speed, you can assemble faster. But many emulators let you run the machine faster than its real speed and then this won't matter.
There are (bascially) 3 processor variants you can target for A2, 6502 (II, II+, and early IIe), 65c02 (enhanced IIe, IIc variants), and 65816 (IIgs), with the last being 16 bit. If you want your code to run on *any* A2 you will want to make sure to limit your operations to those supported by the 6502. Using Merlin 8 will guarantee you are using only 6502 operations, unless you take explicit steps to target others. If you use Merlin 16 or 16+ (running on a IIgs) you will have all the extended operations. You can use pseudo-operations to tell the assembler to prohibit them.
The cross assembler Merlin 32, that runs on modern systems, will target the 65816. It can also generate 6502 code (which is simply a subset). You just have to have the discipline to know which operations you can use. For any serious and sustained project switching to cross assembly is probably inevitable.
BTW mini-assembler is not actually an assembler, all it does is translate mnemonics to op-codes. At least so I read, I never used it, as a kid my IIe was of the unenhanced kind and I had to get by with only the Monitor.
The mini-assembler reads in lines representing instructions (like "txa" or "ora (16,x)") and places the machine codes that they represent in memory. Then it prints out the memory location, the machine code bytes, and the human-readable instruction the way the lister would do.
The way in which this is limited compared to a real assembler is that there are no labels, so you cannot refer to either entry-points or locations by name. Numbers are always in hexadecimal and branch targets must be absolute.
Computing offsets for branches and stuff is one of the biggest time saving parts of using an assembler versus hand assembly. That's where the mini assembler is frustrating because you have to manage all that yourself w/o labels. 6502 assembler is one of the easiest there is out there.