object TAnimal
  param .String, .GetStr, NONE

  method .GetStr
  method .Voice, .prefix
endobj


object TCat, TAnimal
  method .GetStr
endobj


object TDog, TAnimal
  method .GetStr
endobj



method TAnimal.Voice, .prefix
begin
        get     ecx, [.self], TAnimal:String
        jecxz   @f

        stdcall FileWriteString, [STDOUT], [.prefix]
        stdcall FileWriteString, [STDOUT], ecx
@@:
        return
endp


method TAnimal.GetStr
begin
        movx    eax, <'nothing...', 13, 10>
        return
endp


method TCat.GetStr
begin
        movx    eax, <'Meow!', 13, 10>
        return
endp


method TDog.GetStr
begin
        movx    eax, <'Woof!', 13, 10>
        return
endp



start:
        InitializeAll

        create TCat
        mov    esi, eax

        create TDog
        mov    edi, eax

        create TAnimal
        mov    edx, eax

        exec    esi, TAnimal:Voice, 'The cat says '
        exec    edi, TAnimal:Voice, 'The dog says '
        exec    edx, TAnimal:Voice, 'Some animal says '

        stdcall FileReadLine, [STDIN]  ; wait for ENTER

        FinalizeAll
        stdcall TerminateAll, 0    

object MyObj
    .FMyParam dd ?
    param .MyParam, .FMyParam, .FMyParam
endobj    

; get ecx, esi, MyObj:MyParam
    mov  ecx, [esi+MyObj.FMyParam]

; set esi, MyObj:MyParam, eax
   mov  [esi+MyObj:MyParam], eax    

macro create objname {
        stdcall GetMem, sizeof.#objname
        mov     dword [eax], vtables.#objname

   if defined objname#.Create & (objname#.Create and $ffff0000) = cMethodMask
        exec    eax, objname#:Create
   end if
}


macro destroy ptrObj {
   if defined TObject.Destroy & (TObject.Destroy and $ffff0000) = cMethodMask
        exec ptrObj, TObject.Destroy
   end if
       stdcall  FreeMem, ptrObj
}    

struc Animal
{
.Me dd ? ;; address of allocated struc
.Name dd ? ;; StringEmpty
.Noise dd ? ;; StringEmpty
.ToString dd ? ;; AnimalToString
.MakeNoise dd ? ;; AnimalMakeNoise
}

struc Cat
{
.Me dd ? ;; address of allocated struc
.Name dd ? ;; <''>
.Noise dd ? ;; Meow
.ToString dd ? ;; AnimalToString
.MakeNoise dd ? ;; AnimalMakeNoise
.Purr dd ? ;; CatPurr
}

StringEmpty db 0
Meow db 'Meow!', 0

AnimalToString: ;; (this)
 MOV eax, [esp+4] ;; instance object data structure
 MOV eax, [eax + Animal.Name] ;; pointer to name
 RET 4

AnimalMakeNoise: ;; (this, prefix)
 MOV eax, [esp+4] ;; instance object data structure
 MOV ecx, [eax + Animal.Noise] ;; pointer to voice/noise
 MOV edx, [esp+8] ;; prefix
 cinvoke printf, <'%s %s'>, ecx, edx
 RET 8

CatPurr: ;; (this)
 MOV eax, [esp+4] ;; instance object data structure
 PUSH [eax + Animal.Name]
 PUSH [eax + Animal.Noise]
 PUSH eax
 CALL Animal.MakeNoise
 RET 4

NewAnimal: ;; ()
 PUSH Animal.size
 CALL malloc
 MOV [eax + Animal.Me], eax
 MOV ecx, StringEmpty
 MOV [eax + Animal.Name], ecx
 MOV [eax + Animal.Noise], ecx
 MOV ecx, AnimalToString
 MOV [eax + Animal.ToString], ecx
 MOV ecx, AnimalMakeNoise
 MOV [eax + Animal.MakeNoise], ecx
 RET 0

NewCat: ;; (name)
 PUSH Cat.size
 CALL malloc
 MOV [eax + Animal.Me], eax
 MOV ecx, [esp+4] ;; Cat's name
 MOV [eax + Animal.Name], ecx
 MOV ecx, Meow
 MOV [eax + Animal.Noise], ecx
 MOV ecx, AnimalToString
 MOV [eax + Animal.ToString], ecx
 MOV ecx, AnimalMakeNoise
 MOV [eax + Animal.MakeNoise], ecx
 MOV ecx, CatPurr
 MOV [eax + Cat.Purr], ecx
 RET 0

Start:
 stdcall NewAnimal
 MOV esi, eax
 stdcall NewCat, <'Mr. Fluffy'>
 MOV edi, eax

 stdcall [esi + Animal.MakeNoise], esi, <'Animal : '>
 stdcall [edi + Animal.MakeNoise], edi, <'Animal : '>
 stdcall [edi + Cat.Purr], edi

 RET 0
    

mov [esi + TObject.func_001]
...
mov [esi + TObject.func_100]
    

        create TCat 
        istype eax, TAnimal ;; return EAX = TRUE 

        create TAnimal 
        istype eax, TCat ;; return EAX = FALSE 
    

most naive / simple

        create TCat
        mov    esi, eax

        create TDog
        mov    edi, eax

        create TAnimal
        mov    edx, eax

        istype edi, TAnimal
        jne    @f

        stdcall FileWriteString, [STDOUT], <"TDog is TAnimal", 13, 10>
@@:

        istype edi, TCat
        je     @f

        stdcall FileWriteString, [STDOUT], <"TDog is not TCat", 13, 10>
@@:

        exec   esi, TAnimal:Voice, 'The cat says '
        exec   edi, TAnimal:Voice, 'The dog says '
        exec   edx, TAnimal:Voice, 'Some animal says '    

TDog is TAnimal
TDog is not TCat
The cat says Meow!
The dog says Woof!
Some animal says nothing...    

exec   esi, TAnimal:Voice, 'The cat says '    

exec   esi, :Voice, 'The cat says '    

objCat = new Cat() // or Cat.Create()
objCat.Voice()
    

create TAnimal, edx
exec   edx, :Voice, 'Some animal says '
    

Wasn't sure if you could extend the create macro to store the class instance to a parameter and then use some sort of 'virtual at' or other such voodoo to keep the type information for subsequent calls to set, get and exec.

Could you use the type information to make the exec calls shorter where the object name is implied?

The explicit use of the class name in the calls IMHO only makes the code more readable

StringCopy esi, s          ; this?
exec esi, String:Copy, s   ; or this?
DrawImage esi, x, y        ; this?
exec esi, Draw:Image, x, y ; or this?    

or this? is much more readable and informative

the content of esi is totally obscured. What is it?

Dog1 dd ?

        create TDog
        mov    [Dog1], eax

        exec   [Dog1], TAnimal:Voice, 'Dog1 says '