OO Language

I use OOP extensively in my assembly MSX projects. Most of the supporting code is in a shared library project.

For example, look at FileReader.asm, it shows calling convention (“this” in ix, or iy if _IY suffix), constructors, destructors, inheritance, super calling, class definitions… Here’s some code from gunzip which shows instantiation. And here’s my allocator. For my class definitions I rely on a Glass feature to access symbols inside macro definitions as offsets.

Often I also use a lite-version of this class system without dynamic instantiation, and just rely fully on static instantiation, so it uses just the macros and calling conventions and doesn’t need the Class or Heap objects. That’s the case in VGMPlay. In this particular example you can also see some objects stored by reference, and some by value.

I also use the class system quite extensively with generated code btw, embedded in the objects. The downside is that when dynamically allocating you need to make sure the code snippets are relocatable, or fix them up during construction, so it’s easier to use statically. (But gunzip uses it dynamically and gets most of its high performance from that.)

About inheritance; the only difference from composition is that because it comes first in the class definition macro, the ix / iy pointers do not need to be adjusted before calling methods on the base class. Polymorphism I usually implement through either a jp xx as the first content of the class so I can call using jp ix (with the limitation that you can only do this once), or as a simple function reference member which subclasses can override (at the cost of some space each object). A vtable would be simple to do, but it requires some more indirect lookups and so far I haven’t really had the need for it.

I would want to implement some feature in Glass in the future which can do code generation for you (akin to C++ templates), so that e.g. if you want to call a method on a member object, rather than offsetting ix / iy, you can call it like “call Header_Construct(ix + VGM.header)”, which would generate a version of Header_Construct which replaces all instances of ix with ix + VGM.header. But for now this isn’t possible.

I’m curious to hear about your experiences and the choices you’ve made, what works well for you and what doesn’t, etc. Maybe get some new ideas as well.

@Grauw: What I want to build is more than just a way to implement OO in assembly. I'm building a framework that could serve as the base of every MSX project I do, (and possibly for other people too in the future). It's optimized for speed but also to minimize memory usage. It uses a MemoryMapper with 256 byte (or more) blocks for each Object. Each Object has it's own variables and is identified by a 16 bit ObjectId. Classes can inhered functions from a parent class.

I've currently build the following classes / techniques: Object, String, Array, File, VDP, Application, Form, FormControl, Mouse & Keyboard events (on Application, Form or FormControl). Each class having about 20 different functions on average.
I have a priority based MessageQueue for asynchronous execution. And about every function (if possible) has Unit Testing.
It's about 380 files now but compiles down to about 8kb.

So It's been quite a lot of work so far, but I'm fairly pleased with the results so far. I'm not yet ready to publish, but my plans are to make this framework public in the near future and provide the necessary documentation to use it.

Juggling with the mapper pages is always one of the challenging things for me too. There's only so much room to page in the memory, and not always room for calls or routines that 'take forever' . Some good abstraction which still performs quite well could be a great help for this.

far calls. what about labels beyond 64k.
one day I saw some ROM source that looked like it knows some big addresses, I dont know whether there are assemblers who do it.

it would be nice if the assembler doesnt really solve specific cases, but have general purpose mechanism to make all cases.
an address hi hi byte could be a segment. or a slotID.
the assembler needs just big numbers in labels, nothing else

org 0xFF0000
label:
ld a,>>label ;a = 255. second hi byte

org 65536*variable
with -D variable and multiple assembler runs a tool can see which opcode fields change and create lists.

hl,mapper,slotID makes 32bit, assembler needs 32bit numbers
hl,mapper,playsoniq mapper hi byte, slotID, need 40bit numbers

oh maybe one could get the VDP port relocatible the same way
ld a,port98
one time run with -D port98=0, the other time with -D port98=1, opcode fields change, a tool can detect it

I got codes relocatible 256 byte wise in 64k.
at the start of the BIN is code to relocate itself
to make z80 able of pc-relative addressing (get at the tail of the BIN) I poked pop hl : jp (hl) to USR9
CALL that code is like ld hl,pc

I didnt understand "file-pointer magic variable ($$)"?
mhm segment 0 = sysarea, maybe one can hardwire codes to segments 1,2,3 without relocation.
I just liked to think of dynamic library loading scenarios
And the only need I see on the assembler side is bigger variables
the low 16bit used the usual way, while about the upper bits the assembler doesnt know the use
it depends on external tools and on the opcodes used
ld a,>>variable
it could be a mapper segment, it could be a slotID
depends on the package