I've been using FASM (x86) and FASMARM for well over a decade, and mostly enjoying it for its very flexible (though quirky) macro system.

FASMG came out more recently as a universal assembler engine, where you can build your own assembler for any architecture with macros. I just rediscovered it and coded up a J1 CPU assembler in a page of code (though crumby as I haven't really figured out how to do it well)

I just came across a 6502 assembler someone put together https://board.flatassembler.net/topic.php?t=18136

Haven't used it yet, but probably will give it a try, as every 6502 assembler I've used has some awful quirk that drives me crazy.

_________________
x86?  We ain't got no x86.  We don't NEED no stinking x86!

Yeah, I know.

Although I still can't find a workflow/tools that I actually enjoy.

We've gotten spoiled... Back in the day I'd feel happy to have _an_ assembler, and figure out all the tricks of how to use it like a real hacker. Now I download one thing after another, and abandon it after not liking some or other feature. Or worse yet, have a dozen projects each using slightly different syntax, and be unable to pick up where I left off

One thing fasmg has going for it is that it is pretty easy to change the syntax to your liking. And strong macro processing

_________________
x86?  We ain't got no x86.  We don't NEED no stinking x86!

Sounds like fun. But aren't there already lots of native 6502 assemblers? Or are they lacking somehow?

What kind of editing workflow do you use on your 6502 systems? I guess it would be enough to assemble from a big string in memory somewhere to whatever target address? Then you could use remote editor or some local system like forth screens or whatever?

[edit]

A couple of times I've wished that the cross assembler (c65, 64tass etc) could run 6502 code as part of the assembly process, e.g. to calculate a hash or populate a data table. Perhaps allowing native code callouts would be a simple/powerful alternative to traditional assembler macros, keeping the assembler itself simple?

_________________
x86?  We ain't got no x86.  We don't NEED no stinking x86!

That's the exactly the kind of thing Lisp shines at! There is at least one 6502 assembler/simulator I've come across years ago.

BDD, is https://github.com/jdimeglio/6502-Simulator the place to get Kowalski with all the goodies?

I am not looking forward to yet another layer of dealing with windows emulation, but...

_________________
x86?  We ain't got no x86.  We don't NEED no stinking x86!

This is exactly my thinking with the latest Neolithic.

As a complete system, it's only become practical with an external video memory space and external storage: I'm using (planning) a pi pico for the video and IO and a FAT16 compact flash card in 6502 memory space. Because of the way the video works, diverting to serial IO is easy; the file system allows me to use multiple files both as source and as temporary files if required, as well as a destination for the final executable.

There are of course a lot of assumptions behind that system; I'm currently building and testing them as I go before I stick them all together... it'll take a while, but I've still got a few years left in me

Neil

One idea I've been toying with for decades is a hybrid approach: cross-assembling directly into the target 6502 system running a small monitor, interactively. Interaction feels like a forth, but assembly, but you can assemble bits and pieces and run things to test them. I had something like that running on an Apple ][ maybe 20 years ago.

The Apple II comes with a built-in mini assembler... F666G to make it work. It was part of the original Integer Basic ROM set, or loaded from disc with the Apple II+ systems which came with the Applesoft Basic ROM set.

It was literally one line at a time with no source code storage or editing.

Latterly I used the TED II+ assembler on the Apple II for many projects. It had a built-in editor and assembler and supported Sweet 16 too, but I really don't remember if it allowed separate assembly or linkage.

After that; BBC Basic has a built in assembler. It's quirky, but it lets you use BASIC subroutines/functions as a macro. I understand there is now a standalone BeebAsm program which more or less emulates it.

In the BBC Micro world I also used a relocatable assembler that was part of the Acornsoft BCPL package - sadly the sources to it are lost along with all the other Acornsoft stuff, but I have made a start to write one in BCPL under my 65816 BCPL system although I may not finish it as I'm currently happy enough with ca65 for 6502/65C02/65C816 and Sweet 16 work.

-Gordon

_________________
--
Gordon Henderson.
See my Ruby 6502 and 65816 SBC projects here: https://projects.drogon.net/ruby/

Anyway, the reason I posted is that fasmg makes it easy (or at least possible) to create an assembler with a syntax you like, and even add fairly complicated logic to the assembler. I've used the old, less capable fasm macros (on x86) to build pretty complicated external dictionaries for Forth-like systems, and create relocation bitmaps. etc.

Not that we need a new assembler, but it can be useful to do things otherwise not possible without a lot of work reinventing the wheel.

_________________
x86?  We ain't got no x86.  We don't NEED no stinking x86!

Whereas I had my fortieth birthday this year. Though my colleagues at the office were unkind enough to point out that hex is not the usual way of counting birthdays.

Neil

p.s. you know me: nothing is ever set in stone. Except my delight in puns...

_________________
x86?  We ain't got no x86.  We don't NEED no stinking x86!