Is there a way to access a member of a struct/class with assembly inline?

[AGPX]

Hi,

In the following code, I need to implement the assignment 'ns = 1' in assembly. I've tried something like that but with no luck:

struct P
{
	unsigned char ns;
	
	void test()
	{
		ns = 1;   // I need to translate this in assembly....

		__asm {
		    lda #1
		    ldy #0      // <--- how to get the offset of 'ns'?
		    sta (P0),y    // <--- how to get the 'this'?
		}
	}
};

int main()
{
	P a;
	a.test();
	return 0;
}

I've tried to compile it with: oscar64 -O0 test.cpp, obtaining:

P::test: ; P::test(const struct P*)->void
.s0:
0892 : a9 01 __ LDA #$01
0894 : a0 00 __ LDY #$00
0896 : 91 0d __ STA (P0),y ; (this + 0)
0898 : a9 01 __ LDA #$01
089a : a0 00 __ LDY #$00
089c : 91 00 __ STA ($00),y
.s1001:
089e : 60 __ __ RTS
--------------------------------------------------------------------

[drmortalwombat]

void P::test()
{
	auto pns = &ns;

	__asm {
	    lda #1
	    ldy #0      // <--- how to get the offset of 'ns'?
	    sta (pns),y    // <--- how to get the 'this'?
	}
}

This works. Unfortunately if has an issue with the inliner - I will check the issue right away :)

[drmortalwombat]

try with -O2

[AGPX]

The result:

main: ; main()->i16
.s0:
0880 : ad fd 9f LDA $9ffd ; (a + 0)
0883 : 85 43 __ STA T0 + 0
0885 : a9 01 __ LDA #$01
0887 : 8d fe 9f STA $9ffe ; (a + 1)
088a : 85 44 __ STA T0 + 1
088c : a0 00 __ LDY #$00
088e : 84 1b __ STY ACCU + 0
0890 : 84 1c __ STY ACCU + 1
0892 : 91 43 __ STA (T0 + 0),y
.s1001:
0894 : 60 __ __ RTS

It's better, but aliasing still occurs. The problem is that if you have to access many members, you'll end up with a lot of overhead.

[drmortalwombat]

You just ran into the broken inline optimization for "this" and inline assembly that I mentioned. Try defining the function outside of the struct scope.

[drmortalwombat]

You can also:

void P::test()
{
	auto that = this;

	__asm {
	    lda #1
	    ldy #0      // <--- how to get the offset of 'ns'?
	    sta (that),y    // <--- how to get the 'this'?
	}
}

[AGPX]

Ah! I've tried:

struct P
{
	unsigned char ns, ns2;
	
	void test();
};

void P::test()
{
	ns2 = 1;

	auto pns2 = &ns2;

	__asm {
		lda #1
		ldy #0      // <--- how to get the offset of 'ns'?
		sta (pns2),y    // <--- how to get the 'this'?
	}
}

int main()
{
	P a;
	a.test();
	return 0;
}

Now I've the blazing fast:

P::test: ; P::test(const struct P*)->void
.s0:
0892 : a9 01 __ LDA #$01
0894 : a8 __ __ TAY
0895 : 91 0d __ STA (P0),y ; (this + 0)
.s1001:
0897 : 60 __ __ RTS

Thank you! Congratulations for the compiler, I've tried many (including newer ones), but Oscar64 is the best so far from the point of view of optimization and also feature support (class/struct support is very useful!).

[AGPX]

You can also:

void P::test()
{
	auto that = this;

	__asm {
	    lda #1
	    ldy #0      // <--- how to get the offset of 'ns'?
	    sta (that),y    // <--- how to get the 'this'?
	}
}

Mmmh... but how can I get the offset of 'ns' in automatic way? Maybe this could be the best solution, if you could write something like:
ldy #offset ns....

[AGPX]

Mmhhh.... still problems:

struct P
{
	unsigned char ns, ns2;
	
	void test();
};

void P::test()
{
	ns2 = 1;

	auto _ns = ns;
	auto _ns2 = ns2;

	__asm {
		lda #1
		ldy #0
		sta (_ns),y
		lda #2
		sta (_ns2),y
	}
}

int main()
{
	P a;
	a.test();
	return 0;
}

With -O2, I've:

P::test: ; P::test(const struct P*)->void
.s0:
0892 : a9 01 __ LDA #$01
0894 : a8 __ __ TAY
0895 : 91 0d __ STA (P0),y ; (this + 0)
0897 : 88 __ __ DEY
0898 : b1 0d __ LDA (P0),y ; (this + 0)
089a : 85 1b __ STA ACCU + 0
089c : a9 01 __ LDA #$01
089e : 91 1b __ STA (ACCU + 0),y
08a0 : a9 02 __ LDA #$02
08a2 : 85 01 __ STA $01
.s1001:
08a4 : 60 __ __ RTS

STA $01 ?

[AGPX]

Ok solved replacing:

auto _ns = ns;
auto _ns2 = ns2;

with:

auto _ns = &ns;
auto _ns2 = &ns2;

Actually, we need the address of ns and ns2. The code generated is:

P::test: ; P::test(const struct P*)->void
.s0:
0892 : a9 01 __ LDA #$01
0894 : a8 __ __ TAY
0895 : 91 0d __ STA (P0),y ; (this + 0)
0897 : 88 __ __ DEY
0898 : 91 0d __ STA (P0),y ; (this + 0)
089a : a9 02 __ LDA #$02
089c : c8 __ __ INY
089d : 91 0d __ STA (P0),y ; (this + 0)
.s1001:
089f : 60 __ __ RTS

Now it's ok.

[drmortalwombat]

you might want to try

	auto _ns = &ns;
	auto _ns2 = &ns2;

with the ampersand

[AGPX]

Yes, it was typo of mine. Thanks for the quick support!

[drmortalwombat]

I fixed the inline assembler inlining issue, so now you can define the function in the struct definition itself. I also added a P::ns syntax to get the offset of a struct member:

struct P
{
	unsigned char np;
	unsigned char ns;
	
	void test()
	{
		auto that = this;

		__asm {
		    lda #1
		    ldy #P::ns
		    sta (that),y    // <--- how to get the 'this'?
		}
	}
};

[AGPX]

Great addition! I'll try it right away. I have another question: can a constant be accessed in inline assembly? Like:

const unsigned char N = 8;

__asm {
        ldy #N
....
}

[drmortalwombat]

I am sure there are certain situations, but they are rare. Feel free to challenge the compiler and me :)

[drmortalwombat]

BTW you can do:

static const char a = 18;
and later:

lda a

The optimizer will take care of it and replace it with an immediate.

[AGPX]

I'm a maniac of optimizations! I've just translated some code in assembly, because the compiler translation is not too much efficient. I can show a snippet to you:

This C++ code:

const unsigned char MAX_SPRITES = 8;
const unsigned char MAX_ACTOR_SPRITES = 4;

unsigned char    pow2[8] = {1, 2, 4, 8, 16, 32, 64, 128};
unsigned char invPow2[8] = {255-1, 255-2, 255-4, 255-8, 255-16, 255-32, 255-64, 255-128};

unsigned char allocated[MAX_SPRITES];
unsigned char sprMap[256];

class Actor
{
public:
unsigned char  sprN[MAX_ACTOR_SPRITES], ns;

unsigned short x;
unsigned char  y;

void setupFrame();
};

void Actor::setupFrame()
{
  // C++ implementation...
  const auto _ns = ns;
  const auto _x = x;
  const auto _y = y;
  
  unsigned char regy = 1;
  for (unsigned char i = 0; i < _ns; ++i)
  {
	  const unsigned char n = sprN[i];
	  SPR_PTR[n] = sprMap[sprites[regy++]];
  
	  const unsigned short xp = _x + ((signed char)(sprites[regy++]));
	  const unsigned char n2 = n << 1;
	  VIC_PTR[n2] = ((unsigned char)xp);
  
	  if (xp > 255) {
		  *((volatile unsigned char *)0xD010) |= pow2[n];
	  } else {
		  *((volatile unsigned char *)0xD010) &= invPow2[n];
	  }	
  
	  VIC_PTR[n2 + 1] = _y + sprites[regy++];
  
	  COL_PTR[n     ] = sprites[regy];
  
	  if (sprites[regy] & 0x80) {
		  *((volatile unsigned char *)0xD01C) |= pow2[n];
	  } else {
		  *((volatile unsigned char *)0xD01C) &= invPow2[n];
	  }
  
	  ++regy;
  }
}

It's translated (with -O2) to:

Actor::setupFrame: ; Actor::setupFrame(const struct Actor*)->void
.s0:
0b30 : a0 04 __ LDY #$04
0b32 : b1 0d __ LDA (P0),y ; (this + 0)
0b34 : d0 01 __ BNE $0b37 ; (Actor::setupFrame.s11 + 0)
.s1001:
0b36 : 60 __ __ RTS
.s11:
0b37 : 85 1b __ STA ACCU + 0 
0b39 : a9 01 __ LDA #$01
0b3b : 85 1c __ STA ACCU + 1 
0b3d : a9 00 __ LDA #$00
0b3f : 85 1d __ STA ACCU + 2 
0b41 : c8 __ __ INY
0b42 : b1 0d __ LDA (P0),y ; (this + 0)
0b44 : 85 43 __ STA T4 + 0 
0b46 : c8 __ __ INY
0b47 : b1 0d __ LDA (P0),y ; (this + 0)
0b49 : 85 44 __ STA T4 + 1 
0b4b : c8 __ __ INY
0b4c : b1 0d __ LDA (P0),y ; (this + 0)
0b4e : 85 1e __ STA ACCU + 3 
.l2:
0b50 : a0 0e __ LDY #$0e
0b52 : b1 0d __ LDA (P0),y ; (this + 0)
0b54 : 85 46 __ STA T7 + 0 
0b56 : c8 __ __ INY
0b57 : b1 0d __ LDA (P0),y ; (this + 0)
0b59 : 85 47 __ STA T7 + 1 
0b5b : a4 1c __ LDY ACCU + 1 
0b5d : b1 46 __ LDA (T7 + 0),y 
0b5f : aa __ __ TAX
0b60 : a4 1d __ LDY ACCU + 2 
0b62 : b1 0d __ LDA (P0),y ; (this + 0)
0b64 : 85 48 __ STA T9 + 0 
0b66 : a8 __ __ TAY
0b67 : 0a __ __ ASL
0b68 : 85 49 __ STA T10 + 0 
0b6a : bd 00 0f LDA $0f00,x ; (sprMap + 0)
0b6d : 99 f8 f7 STA $f7f8,y 
0b70 : a4 1c __ LDY ACCU + 1 
0b72 : c8 __ __ INY
0b73 : b1 46 __ LDA (T7 + 0),y 
0b75 : 29 80 __ AND #$80
0b77 : 10 02 __ BPL $0b7b ; (Actor::setupFrame.l2 + 43)
0b79 : a9 ff __ LDA #$ff
0b7b : aa __ __ TAX
0b7c : b1 46 __ LDA (T7 + 0),y 
0b7e : 18 __ __ CLC
0b7f : 65 43 __ ADC T4 + 0 
0b81 : 85 45 __ STA T6 + 0 
0b83 : a4 49 __ LDY T10 + 0 
0b85 : 99 00 d0 STA $d000,y 
0b88 : 8a __ __ TXA
0b89 : 65 44 __ ADC T4 + 1 
0b8b : d0 10 __ BNE $0b9d ; (Actor::setupFrame.s5 + 0)
.s1004:
0b8d : a9 ff __ LDA #$ff
0b8f : c5 45 __ CMP T6 + 0 
0b91 : 90 0a __ BCC $0b9d ; (Actor::setupFrame.s5 + 0)
.s6:
0b93 : a6 48 __ LDX T9 + 0 
0b95 : bd 67 0e LDA $0e67,x ; (invPow2 + 0)
0b98 : 2d 10 d0 AND $d010 
0b9b : b0 08 __ BCS $0ba5 ; (Actor::setupFrame.s7 + 0)
.s5:
0b9d : a6 48 __ LDX T9 + 0 
0b9f : bd 5f 0e LDA $0e5f,x ; (pow2 + 0)
0ba2 : 0d 10 d0 ORA $d010 
.s7:
0ba5 : 8d 10 d0 STA $d010 
0ba8 : a4 1c __ LDY ACCU + 1 
0baa : c8 __ __ INY
0bab : c8 __ __ INY
0bac : b1 46 __ LDA (T7 + 0),y 
0bae : 18 __ __ CLC
0baf : 65 1e __ ADC ACCU + 3 
0bb1 : a4 49 __ LDY T10 + 0 
0bb3 : 99 01 d0 STA $d001,y 
0bb6 : 18 __ __ CLC
0bb7 : a5 1c __ LDA ACCU + 1 
0bb9 : 69 03 __ ADC #$03
0bbb : a8 __ __ TAY
0bbc : b1 46 __ LDA (T7 + 0),y 
0bbe : 9d 27 d0 STA $d027,x 
0bc1 : 30 09 __ BMI $0bcc ; (Actor::setupFrame.s8 + 0)
.s9:
0bc3 : bd 67 0e LDA $0e67,x ; (invPow2 + 0)
0bc6 : 2d 1c d0 AND $d01c 
0bc9 : 4c d2 0b JMP $0bd2 ; (Actor::setupFrame.s19 + 0)
.s8:
0bcc : bd 5f 0e LDA $0e5f,x ; (pow2 + 0)
0bcf : 0d 1c d0 ORA $d01c 
.s19:
0bd2 : 8d 1c d0 STA $d01c 
0bd5 : 18 __ __ CLC
0bd6 : a5 1c __ LDA ACCU + 1 
0bd8 : 69 04 __ ADC #$04
0bda : 85 1c __ STA ACCU + 1 
0bdc : e6 1d __ INC ACCU + 2 
0bde : a5 1d __ LDA ACCU + 2 
0be0 : c5 1b __ CMP ACCU + 0 
0be2 : b0 03 __ BCS $0be7 ; (Actor::setupFrame.s19 + 21)
0be4 : 4c 50 0b JMP $0b50 ; (Actor::setupFrame.l2 + 0)
0be7 : 60 __ __ RTS

My manual implementation:

                unsigned char n;
		unsigned char vi, temp;

		const auto _sprN    = sprN;
			  auto _ns      = ns;
		const auto _x = x;
		const auto _y = y;
		const auto _sprites = sprites;

                // ...some other code...

		__asm {

		lda #0 			 // i = 0
		sta vi

		ldy #1                      // reg.y = regy = 1

repeat01:
		lda vi                      // if (i >= ns) goto exit201
		cmp _ns
		bcc sets01
		jmp exit201

sets01:
		sty temp                    // temp = regy
		ldy vi                      // reg.y = i

		lda (_sprN),y               // n = sprN[i]
		sta n

		ldy temp                    // reg.y = temp

		lda (_sprites),y            // reg.x = sprites[regy++]  (sprite ptr)
		iny
		tax
		lda sprMap,x                // reg.a = sprMap[reg.x]
		ldx n     			  	    // reg.x = n
		sta SPR_PTR,x               // SPR_PTR[n] = reg.a

		txa     					// reg.x = n * 2
		asl
		tax

		lda (_sprites),y            // reg.a = sprites[regy]  (offX)
		bmi neg01                   // if (reg.a < 0) goto neg01
		clc
		adc _x
		sta $d000,x                 // VIC_PTR[n * 2] = lo(x + offX)
		lda _x+1
		adc #$00
		jmp cont01

neg01:
		clc
		adc _x
		sta $d000,x                 // VIC_PTR[n * 2] = lo(x + offX)
		lda _x+1
		adc #$FF

cont01:
		stx temp                    // temp = reg.x = n * 2
		beq x8bit01                 // if (hi(x + offX) == 0) goto x8bit01

		lda $d010                   // *((unsigned char *)0xd010) |= pow2[n]
		ldx n
		ora pow2,x
		sta $d010
		jmp skip9bit01              // goto skip9bit01

x8bit01:
		lda $d010                   // *((unsigned char *)0xd010) &= (255 - pow2[n])
		ldx n
		and invPow2,x
		sta $d010

skip9bit01:
		ldx temp                    // reg.x = temp = n * 2

		iny		                    // ++regy

		lda (_sprites),y            // reg.a = sprites[regy]  (offY)
		clc
		adc _y
		sta $d001,x                 // VIC_PTR[n * 2 + 1] = y + offY
		iny		                    // ++regy

		lda (_sprites),y            // reg.a = sprites[regy++]  (col)
		iny
		ldx n
		sta COL_PTR,x               // temp2 = COL_PTR[n] = reg.a

		and #$80
		beq monocol01               // if ((COL_PTR[n] & 0x80) = 0) goto monocol01

		lda $d01c                   // *((unsigned char *)0xd01c) |= pow2[n]
		ora pow2,x
		sta $d01c
		jmp skipCol01               // goto skipCol01

monocol01:
		lda $d01c                   // *((unsigned char *)0xd01c) &= (255 - pow2[n])
		and invPow2,x
		sta $d01c

skipCol01:
		inc vi                      // ++i
		jmp repeat01                // goto repeat01

exit201:
	};

The translation of Oscar64 is very good, but in my implementation I've optimized the usage of X and Y registers avoiding to use too much temporary registers (only temp).

[drmortalwombat]

Can you give me a compilable sample? I am missing the definition of "sprites" and "SPR_PTR".

[AGPX]

#include <string.h>

const unsigned char __Sprites__[] = {
	0, 0, 0, 0, 2, 0, 0, 7, 0, 0, 7, 0, 0, 14, 0, 0, 12, 0, 0, 28, 0, 0, 60, 0, 0, 60, 0, 0, 60, 0, 0, 62, 0, 0, 28, 0, 0, 30, 0, 0, 30, 0, 1, 254, 0, 3, 246, 0, 2, 6, 0, 0, 6, 0, 0, 6, 0, 0, 6, 0, 0, 7, 0, 0, 
0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 7, 0, 0, 7, 0, 0, 14, 0, 0, 28, 0, 0, 60, 0, 0, 125, 0, 0, 127, 0, 0, 62, 0, 0, 28, 0, 0, 28, 0, 0, 28, 0, 0, 12, 0, 0, 124, 0, 0, 252, 0, 0, 140, 0, 0, 12, 0, 0, 8, 0, 0, 12, 0, 0, 
0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 7, 0, 0, 7, 0, 0, 14, 0, 0, 28, 64, 0, 62, 192, 0, 127, 128, 0, 221, 0, 0, 220, 0, 0, 124, 0, 0, 62, 0, 0, 30, 0, 0, 27, 0, 0, 31, 0, 0, 60, 0, 0, 112, 0, 0, 96, 0, 0, 192, 0, 0, 96, 0, 0, 
0, 0, 0, 0, 2, 0, 0, 7, 0, 0, 7, 0, 0, 14, 0, 0, 28, 0, 0, 60, 0, 0, 124, 0, 0, 125, 128, 0, 63, 0, 0, 28, 0, 0, 28, 0, 0, 60, 0, 0, 54, 0, 0, 99, 0, 0, 99, 0, 0, 198, 0, 1, 134, 0, 3, 3, 0, 1, 128, 0, 0, 0, 0, 0, 
0, 0, 0, 0, 2, 0, 0, 7, 0, 0, 7, 0, 0, 14, 0, 0, 12, 0, 0, 28, 0, 0, 60, 0, 0, 60, 0, 0, 62, 0, 0, 28, 0, 0, 28, 0, 0, 30, 0, 0, 63, 0, 0, 115, 0, 0, 225, 128, 7, 193, 128, 15, 1, 128, 8, 1, 224, 0, 0, 192, 0, 0, 0, 0, 
0, 0, 0, 0, 2, 0, 0, 7, 0, 0, 7, 0, 0, 14, 0, 0, 12, 0, 0, 28, 0, 0, 28, 0, 0, 28, 0, 0, 28, 0, 0, 28, 0, 0, 28, 0, 0, 28, 0, 0, 28, 0, 0, 60, 0, 7, 246, 0, 15, 230, 0, 8, 6, 0, 0, 3, 0, 0, 3, 0, 0, 3, 128, 0

};

#define MAX_SPRITES 8

const unsigned char MAX_ACTOR_SPRITES = 4;

#define MEM_VIDEO 62464
unsigned char *const SPR_PTR   = (unsigned char *const)(MEM_VIDEO + 1016);
unsigned char *const VIC_PTR   = (unsigned char *const)0xD000;
unsigned char *const COL_PTR   = (unsigned char *const)0xD027;

unsigned char    pow2[8] = {1, 2, 4, 8, 16, 32, 64, 128};
unsigned char invPow2[8] = {255-1, 255-2, 255-4, 255-8, 255-16, 255-32, 255-64, 255-128};

unsigned char sprMap[256];

class Actor
{
public:
	unsigned char  sprN[MAX_ACTOR_SPRITES], ns;

	unsigned short x;
	unsigned char  y;

	unsigned char *sprites;   // ns, (sprIx, offX, offY, col+multi(8th-bit)  (times 'ns'))
	
	Actor();

	void setupFrame();
};

Actor::Actor() : ns(0), sprites(nullptr) { memset(sprN, 255, MAX_ACTOR_SPRITES); }

void Actor::setupFrame()
{
    const auto _ns = ns;     // I've introduced these 3 auto vars, to free the register "y" a bit more....
    const auto _x = x;
    const auto _y = y;
    
    unsigned char regy = 1;
    for (unsigned char i = 0; i < _ns; ++i)
    {
	    const unsigned char n = sprN[i];
	    SPR_PTR[n] = sprMap[sprites[regy++]];
    
	    const unsigned short xp = _x + ((signed char)(sprites[regy++]));
	    const unsigned char n2 = n << 1;
	    VIC_PTR[n2] = ((unsigned char)xp);
    
	    if (xp > 255) {       // N.B.: In assembly this is just a check of the high byte. A syntax like "(>xp != 0)" to access the high byte would be nice...
		    *((volatile unsigned char *)0xD010) |= pow2[n];
	    } else {
		    *((volatile unsigned char *)0xD010) &= invPow2[n];
	    }	
    
	    VIC_PTR[n2 + 1] = _y + sprites[regy++];
    
	    COL_PTR[n     ] = sprites[regy];
    
	    if (sprites[regy] & 0x80) {
		    *((volatile unsigned char *)0xD01C) |= pow2[n];
	    } else {
		    *((volatile unsigned char *)0xD01C) &= invPow2[n];
	    }
    
	    ++regy;
    }

}

int main()
{
	Actor a;
	a.setupFrame();
	return 0;
}

[AGPX]

BTW you can do:

static const char a = 18; and later:

lda a

The optimizer will take care of it and replace it with an immediate.

I've tried (-O2):

static const unsigned char MAX_SPRITES = 8;

                inx                         // ++i
		cpx MAX_SPRITES             // if (i != MAX_SPRITES) goto loopI01
		bne loopI01
		jmp setNs01                 // goto setNs01

but it's translated in:

0c31 : e8 __ __ INX
0c32 : ec 7c 0f CPX $0f7c ; (MAX_SPRITES + 0)
0c35 : d0 df __ BNE $0c16 ; (Actor::setupFrame.s0 + 73)
0c37 : 4c 59 0c JMP $0c59 ; (Actor::setupFrame.s0 + 140)

...

--------------------------------------------------------------------
MAX_SPRITES:
0f7c : __ __ __ BYT 08                                              : .
--------------------------------------------------------------------

So, no immediate mode translation.

[AGPX]

Ok, I've compiled the source of Oscar64 with VS2022, but the code is not compiling anymore!

Error during the start of the process.

call oscar64 -O2 -o=c:\tmp\game.prg c:\tmp\code.cpp
c:/tmp/code.cpp(552, 18) : error 3012: Cannot assign incompatible types 'const struct Player*' != 'struct Player'
c:/tmp/code.cpp(605, 2) : error 3012: Cannot assign incompatible types 'const struct Player*' != 'struct Player'
c:/tmp/code.cpp(597, 91) : error 3012: Cannot assign incompatible types 'const struct Actor*' != 'struct Player'
c:/tmp/code.cpp(564, 1) : error 3012: Cannot assign incompatible types 'const struct Player*' != 'struct Player'
c:/tmp/code.cpp(566, 1) : error 3012: Cannot assign incompatible types 'const struct Actor*' != 'struct Player'
c:/tmp/code.cpp(568, 1) : error 3012: Cannot assign incompatible types 'const struct Player*' != 'struct Player'
c:/tmp/code.cpp(572, 1) : error 3012: Cannot assign incompatible types 'const struct Actor*' != 'struct Player'

[drmortalwombat]

would you share your source, so I can recreate the issue? BTW you can find me on the "Everything C64" discord

[AGPX]

This works with current released binary:

class Player
{
public:
	void __execute__();
};

void Player::__execute__()
{
	
}

class Level1
{
public:
	void __execute__();

	Player player;
};

void Level1::__execute__()
{
	player.__execute__();             // <-------- the error is here (line 22)
}

Level1 Level1inst;

int main()
{
	Level1inst.__execute__();
	return 0;
}

but not with latest source cloned from git! You've:

C:/tmp/code.cpp(22, 2) : error 3012: Cannot assign incompatible types 'const struct Player*' != 'struct Player'

Looks like that the 'player' type is now a pointer to a constant struct instead of a struct....

[drmortalwombat]

I can reproduce

[drmortalwombat]

Fix checked in