Knowledge required to make changes?

[Wysardry]

Writing or even just modifying compilers is way outside my current experience, so I would like a few pointers on what I would need to learn before attempting to modify ACK.

First of all, I would like to add several new target platforms. These would be emulated 8-bit machines with a Z80 or 6809 processor. I would hope to also support physical machines, but I don't currently have access to any.

If I manage that, I would like to add support for a new programming language. This would be ANSI Full BASIC (without the optional graphics module).

If all goes well, I would then like to attempt to add support for a new domain specific language.

Would I need to learn C for any of these tasks? If so, which standard? C89, C99, C11 or something else?

How about Lua, Flex and Yacc/Bison? Assembly language?

[davidgiven]

There is actually a BASIC compiler already present --- it's ancient and eccentric, though. https://github.com/davidgiven/ack/tree/default/lang/basic There's an example in examples/hilo.bas.

Adding a new target in the ACK is probably easier than most other compilers, but still pretty hard. There are two real parts: the platform-dependent stuff (in plat) and the architecture-dependent stuff (in mach). The former describes things like the system call interface, memory layout, startup code, etc. The latter has the code generator, run-time library, assembler, etc.

I'd probably recommend starting with your z80-based machine, but using the 8080 code generator, because that already exists and is known to work. This basically involves copying plat/cpm , adding it to vars.plats in build.lua, and changing the obvious things. The only option of much interest is -DUSE_I80_RSTS in plat/cpm/build-tools.lua which tells the code generator to use rst helpers to do things like parameter access.

In terms of adding a new code generator: you have a choice of three. cg is the old code expander, which is very simple and fast but produces terrible code. This has had very little exercise. See mach/z80/cg. There's ncg, which is newer. This is good for memory-operand machines and is probably the best one for the Z80. See mach/vc4/ncg. The last one is mcg, which is a brand new one which I wrote, which is supposed to be good for register-operand machines but didn't really live up to expectations. See mach/mips/mcg. All this stuff is nominally in C, but there's not a lot of code you actually need to write.

In terms of adding a new language: it's reasonably straightforward. There's a C library which generates the EM bytecode; you emit stack-based code, and this does the rest. See lang/b/compiler and all the function calls starting with C_. You can use flex and bison if you want but there's nothing requiring this. Lua is only used by the build scripts (and these need to be replaced). If you're writing new code it would be nice to have it be C89, because then there's a possibility of self-compilation with the ACK, but as that doesn't work yet and there's a lot of C99 code already present I wouldn't worry about it.

[Wysardry]

Thanks. I have read some of the documentation on the existing BASIC compiler, but it seems quite minimal to me.

It looks to be roughly equivalent to Microsoft BASIC V2, as used on the Commodore 64, Dragon 32 etc. I would like something more structured, along the lines of QuickBASIC, ByWater BASIC or Decimal BASIC.

I had planned to start with one of the Z80 platforms first, as I previously owned several of them and there seems to be information available than for the 6809.

plat/cpm seems to be for the CP/M operating system. Would it also be suitable for tape based Z80 machines?

I only have a vague idea about how to create a new programming language. I had the impression that tools such as Flex and Bison were needed to map the syntax of the programming language to EM and/or EM to assembly code.

So, books and tutorials on C89 would be most useful, with some sort of C99 reference in case I encounter ACK code using that standard?

The few 8-bit C cross compilers I've seen seem to support all of C89 with a handful of features from C99. I'm now wondering if ACK could ever run on a Z80 system.

[davidgiven]

You might want to look at NeoBasic, which is a new structured BASIC for the neo6502: https://github.com/paulscottrobson/neo6502-firmware/blob/main/documents/release/basic.odt

Regarding Flex and Bison: these implement what's known as the parsing stage of any compiler, which involves reading the user's text and turning it into something the compiler can work with. There are hundreds of approaches here. Flex and Bison are some of the more traditional and the ACK tends to use these a lot, alongside its own parser generator called llgen, but they're not required. For another project I'm currently converting a compiler from using a parser generator called Lemon to a hand-tooled parser. For more information, there's an excellent book on writing programming languages here: https://craftinginterpreters.com/contents.html It's oriented around interpreters, but there's suprisingly little difference between an interpreter and a compiler.

Re plat/cpm: most of the system call library is oriented around working with files, because that's basically the only thing CP/M can do, but it's all optional. You might want to compare it with plat/pc86 which produces bootable floppy disks for PCs, which has no file system support at all. For a tape system, I suspect that's more the model you're looking for.

The smallest system I've seen the ACK run on was Minix, where each process could have up to 128kB of RAM (64kB code, 64kB data). That needed some heavy tweaks to make work. I suspect a Z80 system, with half as much memory and less dense code, would be simply too small.

[Wysardry]

I'm more intrigued by the neo6502 itself than neoBASIC. It would be nice to add support for that and other 8-bit mini computers to ACK at some point.

The reason I would like to focus on ANSI Full BASIC is that it was used for an interpreter on a Z80 computer in the 80s (the Enterprise 64), so there shouldn't be any problems with a compiled version. There's also a modern Full BASIC interpreter called Decimal BASIC that runs on Windows, Mac, Linux and Raspberry Pi.

I have been browsing various books and sites on writing compilers and interpreters, but it's hard to know which would be applicable as there are so many different approaches and programming languages.

From what I remember, each of the 8-bit systems had their own hardware-based operating systems, so I will likely need to create a file in plat for each of those. Some of the Z80 systems did also support CP/M, although I don't recall ever using it on the one Z80 system I used to own with a disk drive (Amstrad CPC6128), unless that's how the Infocom text adventures were implemented.

Some of the later Z80 machines could support more than 64Kb via bank switching. Amstrad, Enterprise, Spectrum, Memotech and others produced 128Kb computers.

The Enterprise could be expanded to use up to 4Mb, although they went bankrupt before they could release any memory expansion addons. I did see a modified Enterprise 128 at a user group event in the mid 80s that had been put in a PC case, had a Z80B processor (instead of the Z80A) and expanded to (I think) 512Kb of RAM.

Whether running ACK itself on such a system would have any benefits is debatable though. I guess it would depend on how much effort is involved in transferring cross-compiled programs to physical machines.