trace:steam_api:SteamAPI_RestartAppIfNecessary_ ((uint32 )[спрятан])
trace:steam_api:SteamAPI_RestartAppIfNecessary_ () = (bool )0
trace:steam_api:SteamAPI_Init_ ()
Setting breakpad minidump AppID = [спрятан]
Steam_SetMinidumpSteamID:  Caching Steam ID:  [спрятан] [API loaded no]
trace:steam_api:SteamAPI_Init_ () = (bool )1
trace:steam_api:SteamInternal_ContextInit_ ((void *)0x7ee468)
trace:steam_api:SteamAPI_GetHSteamPipe_ ()
trace:steam_api:SteamAPI_GetHSteamPipe_ () = (HSteamPipe )0x1
trace:steam_api:SteamAPI_GetHSteamUser_ ()
trace:steam_api:SteamAPI_GetHSteamUser_ () = (HSteamUser )0x1
trace:steam_api:SteamAPI_GetHSteamPipe_ ()
trace:steam_api:SteamAPI_GetHSteamPipe_ () = (HSteamPipe )0x1
trace:steam_api:SteamInternal_CreateInterface_ ((char *)"SteamClient017")
wine: Unhandled privileged instruction at address 0x7a3a3c92 (thread 0009), starting debugger...
Unhandled exception: privileged instruction in 32-bit code (0x7a3a3c92).

Примечание: этот лог более информативен, чем формируемый обёрткой, сгенерированной описанным выше способом, но сути проблемы это не меняет.

trace:steam_api:SteamAPI_RestartAppIfNecessary_ ((uint32 )[спрятан])
trace:steam_api:SteamAPI_RestartAppIfNecessary_ () = (bool )0
trace:steam_api:SteamAPI_Init_ ()
Setting breakpad minidump AppID = [спрятан]
Steam_SetMinidumpSteamID:  Caching Steam ID:  [спрятан] [API loaded no]
trace:steam_api:SteamAPI_Init_ () = (bool )1
trace:steam_api:SteamInternal_ContextInit_ ((void *)0x7ee468)
trace:steam_api:SteamAPI_GetHSteamPipe_ ()
trace:steam_api:SteamAPI_GetHSteamPipe_ () = (HSteamPipe )0x1
trace:steam_api:SteamAPI_GetHSteamUser_ ()
trace:steam_api:SteamAPI_GetHSteamUser_ () = (HSteamUser )0x1
trace:steam_api:SteamAPI_GetHSteamPipe_ ()
trace:steam_api:SteamAPI_GetHSteamPipe_ () = (HSteamPipe )0x1
trace:steam_api:SteamInternal_CreateInterface_ ((char *)"SteamClient017")
trace:steam_api:SteamInternal_CreateInterface_ (): (ISteamClient *)0x7a7a04c8 wrapped as (ISteamClient_ *)0x7c49bc70
trace:steam_api:SteamInternal_CreateInterface_ () = (ISteamClient_ *)0x7c49bc70
trace:steam_api:GetISteamUser ((ISteamClient *)0x7c49bc70, (HSteamUser )0x1, (HSteamPipe )0x1, (char *)"SteamUser019")
trace:steam_api:GetISteamUser () = (ISteamUser *)0x7c4bcc40
trace:steam_api:GetISteamFriends ((ISteamClient *)0x7c49bc70, (HSteamUser )0x1, (HSteamPipe )0x1, (char *)"SteamFriends015")
trace:steam_api:GetISteamFriends () = (ISteamFriends *)0x7c4b8650
trace:steam_api:GetISteamUtils ((ISteamClient *)0x7c49bc70, (HSteamPipe )0x1, (char *)"SteamUtils008")
trace:steam_api:GetISteamUtils () = (ISteamUtils *)0x7c4b7930
trace:steam_api:GetISteamMatchmaking ((ISteamClient *)0x7c49bc70, (HSteamUser )0x1, (HSteamPipe )0x1, (char *)"SteamMatchMaking009")
trace:steam_api:GetISteamMatchmaking () = (ISteamMatchmaking *)0x7c4c03c0
trace:steam_api:GetISteamMatchmakingServers ((ISteamClient *)0x7c49bc70, (HSteamUser )0x1, (HSteamPipe )0x1, (char *)"SteamMatchMakingServers002")
trace:steam_api:GetISteamMatchmakingServers () = (ISteamMatchmakingServers *)0x7c4b5450
trace:steam_api:GetISteamUserStats ((ISteamClient *)0x7c49bc70, (HSteamUser )0x1, (HSteamPipe )0x1, (char *)"STEAMUSERSTATS_INTERFACE_VERSION011")
trace:steam_api:GetISteamUserStats () = (ISteamUserStats *)0x7c4b5e10
trace:steam_api:GetISteamApps ((ISteamClient *)0x7c49bc70, (HSteamUser )0x1, (HSteamPipe )0x1, (char *)"STEAMAPPS_INTERFACE_VERSION008")
trace:steam_api:GetISteamApps () = (ISteamApps *)0x7c4b73a0
trace:steam_api:GetISteamNetworking ((ISteamClient *)0x7c49bc70, (HSteamUser )0x1, (HSteamPipe )0x1, (char *)"SteamNetworking005")
trace:steam_api:GetISteamNetworking () = (ISteamNetworking *)0x7c49cd40
trace:steam_api:GetISteamRemoteStorage ((ISteamClient *)0x7c49bc70, (HSteamUser )0x1, (HSteamPipe )0x1, (char *)"STEAMREMOTESTORAGE_INTERFACE_VERSION014")
trace:steam_api:GetISteamRemoteStorage () = (ISteamRemoteStorage *)0x7c4c1610
trace:steam_api:GetISteamScreenshots ((ISteamClient *)0x7c49bc70, (HSteamUser )0x1, (HSteamPipe )0x1, (char *)"STEAMSCREENSHOTS_INTERFACE_VERSION003")
trace:steam_api:GetISteamScreenshots () = (ISteamScreenshots *)0x7c4b70b0
trace:steam_api:GetISteamHTTP ((ISteamClient *)0x7c49bc70, (HSteamUser )0x1, (HSteamPipe )0x1, (char *)"STEAMHTTP_INTERFACE_VERSION002")
trace:steam_api:GetISteamHTTP () = (ISteamHTTP *)0x7c4b5c50
trace:steam_api:GetISteamUnifiedMessages ((ISteamClient *)0x7c49bc70, (HSteamUser )0x1, (HSteamPipe )0x1, (char *)"STEAMUNIFIEDMESSAGES_INTERFACE_VERSION001")
trace:steam_api:GetISteamUnifiedMessages () = (ISteamUnifiedMessages *)0x7c49e680
trace:steam_api:GetISteamController ((ISteamClient *)0x7c49bc70, (HSteamUser )0x1, (HSteamPipe )0x1, (char *)"SteamController005")
trace:steam_api:GetISteamController () = (ISteamController *)0x7c49bfd0
trace:steam_api:GetISteamUGC ((ISteamClient *)0x7c49bc70, (HSteamUser )0x1, (HSteamPipe )0x1, (char *)"STEAMUGC_INTERFACE_VERSION009")
trace:steam_api:GetISteamUGC () = (ISteamUGC *)0x7c49cad0
trace:steam_api:GetISteamAppList ((ISteamClient *)0x7c49bc70, (HSteamUser )0x1, (HSteamPipe )0x1, (char *)"STEAMAPPLIST_INTERFACE_VERSION001")
trace:steam_api:GetISteamAppList () = (ISteamAppList *)0x7c49c450
trace:steam_api:GetISteamMusic ((ISteamClient *)0x7c49bc70, (HSteamUser )0x1, (HSteamPipe )0x1, (char *)"STEAMMUSIC_INTERFACE_VERSION001")
trace:steam_api:GetISteamMusic () = (ISteamMusic *)0x7c49cbf0
trace:steam_api:GetISteamMusicRemote ((ISteamClient *)0x7c49bc70, (HSteamUser )0x1, (HSteamPipe )0x1, (char *)"STEAMMUSICREMOTE_INTERFACE_VERSION001")
trace:steam_api:GetISteamMusicRemote () = (ISteamMusicRemote *)0x7c49e710
trace:steam_api:GetISteamHTMLSurface ((ISteamClient *)0x7c49bc70, (HSteamUser )0x1, (HSteamPipe )0x1, (char *)"STEAMHTMLSURFACE_INTERFACE_VERSION_003")
trace:steam_api:GetISteamHTMLSurface () = (ISteamHTMLSurface *)0x7c49ccb0
trace:steam_api:GetISteamInventory ((ISteamClient *)0x7c49bc70, (HSteamUser )0x1, (HSteamPipe )0x1, (char *)"STEAMINVENTORY_INTERFACE_V001")
trace:steam_api:GetISteamInventory () = (ISteamInventory *)0x7c49d0c0
trace:steam_api:GetISteamVideo ((ISteamClient *)0x7c49bc70, (HSteamUser )0x1, (HSteamPipe )0x1, (char *)"STEAMVIDEO_INTERFACE_V001")
trace:steam_api:GetISteamVideo () = (ISteamVideo *)0x7c49cb60
trace:steam_api:SetOverlayNotificationPosition ((ISteamUtils *)0x7c4b7930, (ENotificationPosition )0x2)
trace:steam_api:SteamInternal_ContextInit_ ((void *)0x7ee468)
trace:steam_api:SetWarningMessageHook ((ISteamUtils *)0x7c4b7930, (SteamAPIWarningMessageHook_t )0x52ebb0)

const specname {.strdefine.} = "steam_api.spec" # spec файл пригодится во время компиляции, потому принимаем путь к нему через опцию `-d:specname=/path/to/steam_api.spec` с помощью прагмы {.strdefine.} и записываем в константу `specname`.
# Если опция не задана, в константу запишется значение по умолчанию — "steam_api.spec".
{.passL: "'" & specname & "'".} # Также передаем путь к spec файлу линкеру в качестве аргумента.

# Описываем макрос TRACE из заголовочных файлов wine, который поможет нам при отладке
proc trace*(format: cstring)
  {.varargs, importc: "TRACE", header: """#include <stdarg.h>
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(steam_api);""".}
# Прагма varargs указывает, что после первого аргумента могут быть ещё, прагма importc — как должно выглядеть имя при вызове в Си коде, прагма header — что должно быть помещено в шапку Си файла, где происходит вызов.
# Строго говоря, Nim понятия не имеет что такое TRACE. Зато теперь он знает, как можно вызвать TRACE в коде на Си.

# Эта функция сгенерирована winedump'ом, потому включаем её в промежуточный код на Си почти без изменений.
{.emit:["""
BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, void *reserved)
{
    """, trace, """("(%p, %u, %p)\n", instance, reason, reserved); // вызываем именно описанный нами макрос, чтобы не ломать зависимости от заголовочных файлов
    switch (reason)
    {
        case DLL_WINE_PREATTACH:
            return FALSE;    /* prefer native version */
        case DLL_PROCESS_ATTACH:
            DisableThreadLibraryCalls(instance);
            NimMain(); // инициализируем сборщик мусора и рантайм Nim
            break;
    }
    return TRUE;
}
"""].}

--app:lib # мы создаём библиотеку steam_api.dll.so, а не исполняемый файл
--passL:"-mno-cygwin" # несколько специальных опций передаём winegcc напрямую
--passC:"-mno-cygwin" # на самом деле это вовсе не опция, а макрос `--`, который эмулирует поведение опций компилятора
--passC:"-D__WINESRC__" # а сам файл написан на подмножестве языка Nim
--os:windows # хотя библиотека компилируется в linux, wine предоставляет нам функции WinAPI
--noMain # Мы создали свою функцию `DllMain`, поэтому не нужно, чтобы Nim создал ещё одну
--cc:gcc # явно указываем семейство компилятора C
# Дальше придётся использовать `switch`, так как макрос `--` не поддерживает точки в имени опции
switch("gcc.exe", "/usr/bin/winegcc") # а также путь к самому компилятору и линкеру
switch("gcc.linkerexe", "/usr/bin/winegcc") # я уже говорил что `switch` и `--` эквивалентны?

[...]
[...]
[...]
[адрес возврата] <= ESP
[аргумент 1]
[аргумент 2]
[???]

[адрес возврата в ассемблерный фрагмент] <= ESP
[номер метода]
[указатель на объект = %ecx]
[адрес возврата]
[аргумент 1]
[аргумент 2]
[???]

[адрес возврата в ассемблерный фрагмент]
[номер метода]
[указатель на объект = %ecx]
[адрес возврата]
[аргумент 1]
[аргумент 2]
[???] <= ESP

proc pseudoMethod4(methodNo: uint32, obj: ptr WrappedObject, retAddress: pointer, argument1: pointer) : uint64 {.cdecl.} =
  # Название метода pseudoMethod<глубина стека>
  # methodNo - порядковый номер метода в виртуальной таблице начиная с 0
  # obj - указатель на обертку объекта
  # retAddress - адрес возврата в код игры (не используется)
  # argument1 - аргумент, передаваемый в метод
  # возвращаем uint64, так как наверняка неизвестно, будет ли возвращено 64 битное значение в регистрах EAX и EDX или 32 битное в EAX.
  # прагма cdecl говорит компилятору, что он должен следовать соглашениям о вызовах Си
    trace("Method No %d was called for obj=%p and return to %p\n",
          methodNo, obj, retAddress)
    trace("(%p)\n", argument1)
    trace("Origin = %p\n", obj.origin)
    let vtableaddr = obj.origin.vtable
    trace("Origins VTable = %p\n", vtableaddr) # просто выводим всю информацию о методе для отладки
    let maddr = cast[ptr proc(obj: pointer argument1: pointer): uint64](cast[uint32](vtableaddr) + methodNo*4) # вычисляем положение адреса оригинального метода
    trace("Method address to call: %p\n", maddr)
    let themethod = maddr[] # получаем адрес оригинального метода
    trace("Method to call: %p\n", themethod)
    let res = themethod(obj.origin, argument1) # вызываем оригинальный метод (соглашения о вызовах GCC)
    trace("Result = %p\n", res)
    return wrapIfNecessary(res) # если результат - указатель на объект, то оборачиваем его и возвращаем обёртку.

from strutils import splitLines, split, parseInt
from tables import initTable, `[]`, `[]=`, pairs, Table
type
  StackState* = tuple 
    # информация о стеке для конкретного метода
    depth: int # глубина стека
    swap: bool # индикатор наличия скрытого аргумента
  Classes* = Table[string, seq[StackState]] ## таблица, которую мы хотим получить: ключи — имена классов (CAdapterSteamYYY0XX), значения — списки глубин стека каждого метода

const cdfile {.strdefine.} = ""
  # по аналогии с прошлым случаем, получаем путь к файлу из опций компилятора

proc readClasses(): Classes {.compileTime.} =
  # прагма compileTime явно указывает компилятору, что не нужно генерировать код для этой функции
  result = initTable[string, seq[StackState]]() # result — неявная переменная, которая будет возвращена в конце функции
  let filedata = slurp(cdfile) # во время компиляции файл читается функцией `slurp`, в то время как обычные функции работы с файлами недоступны
  for line in filedata.splitLines():
    if line.len == 0:
      continue
    elif line[0] == '!':
      let curstr = line[1..^1] # подстрока с первого по последний символ
      result[curstr] = newSeq[StackState]()
    else:
      let depth = parseInt(line)
      let swap = line[0] == '+' # в качестве индикатора скрытого аргумента служит знак "+" перед глубиной стека
      # он не влияет на распознавание числа и очень легко проверяется
      result[curstr].add((depth: depth, swap: swap)) # Именованный кортеж не требует особого конструктора с именем типа
  # возврата нет, так как в result и так записано возвращаемое значение

static:
  # Ключевое слово static указывает, что работа с переменными происходит во время компиляции.
  var declared: set[uint8] = {} # глубины стека, для которых нужно будет создать псевдометоды
  var swpdeclared: set[uint8] = {} # глубины стека, для которых нужно будет создать псевдометоды со скрытым аргументом

proc eachMethod(k: string, methods: seq[StackState], sink: NimNode): NimNode {.compileTime.} =
  # создаёт декларацию функции и присваивает её `k`тому элементу в таблице с идентификатором `sink`
  # NimNode - любой элемент АСД. В нашем случае это идентификатор на входе и список выражений на выходе.
  result = newStmtList() # пустой список выражений языка
  let kString = newStrLitNode k # превращение строки в узел АСД, означающий строку
  # Unified Call Syntax позволяет записывать вызовы функций как душе угодно, конкретно верхний эквивалентен newStrLitNode(k), k.newStrLitNode() и k.newStrLitNode (стиль изменён для демострации)
  result.add quote do: # quote - особый макрос, создающий АСД для участка кода, переданного ему в качестве аргумента, а `do` позволяет превратить в аргумент код под ним
    `sink`[`kString`] = newSeq[MethodProc](2) # всё, что в кавычках будет подставлено в АСД без изменений
  for i, v in methods.pairs():
    if v.swap: # подсчёт псевдометодов, которые предстоит создать
      swpdeclared.incl(v.depth.uint8) # неявные преобразования типов не допускаются
    else:
      declared.incl(v.depth.uint8)
    # Уже знакомая нам ассемблерная вставка в виде строки с комментариями.
    # Необходимые значения вклеиваются в неё оператором конкатенации `&`.
    # Тройные кавычки ведут себя также как в питоне.
    let asmcode = """
    push %ecx # помещаем в стек указатель на объект
    push $0x""" & i.toHex & """ # затем номер метода в виртуальной таблице
    call `pseudoMethod""" & $v.depth & (if v.swap: "S" else: "") & #конструкции if-elif-else и case-of-else могут быть выражениями возвращающими результат
      """` # вызываем псевдометод
    add $0x4, %esp # убираем из стека номер метода
    pop %ecx # возвращаем указатель на объект в регистр ECX и чистим от него стек
    ret $""" & $(v.depth-4) &  """ # чистим стек от остальных аргументов и возвращаемся
"""
    var tstr = newNimNode(nnkTripleStrLit) # nnkTripleStrLit это тип узла АСД для строки в тройных кавычках
    tstr.strVal = asmcode # превращаем строку в узел АСД эквивалентный этой строке
    let asmstmt = newTree(nnkAsmStmt, newEmptyNode(), tstr) # а затем в узел АСД эквивалентный выражению `asm """<код>"""`
    let methodname = newIdentNode("m" & k & $i) # создаём идентификатор метода как `m<имя класса><номер метода>`
    result.add quote do: # вклеиваем в шаблон декларации функции и добавляем полученное АСД к общему списку
      proc `methodname` () {.asmNoStackFrame, noReturn.} = # декларация функции
        # прагма asmNoStackFrame должна указать компилятору, не создавать новый фрейм в стеке
        # прагма noReturn говорит компилятору, что возврат сделан вручную и генерировать для этого код не нужно
        `asmstmt`
    # присваивание
    add(`sink`[`kString`], `methodname`) # макросу quote не всегда удаётся правильно понять конструкцию с вклеенными кусками АСД, потому иногда приходится призывать на помощь UCS и видоизменить вызов

proc makePseudoMethod(stack: uint8, swp: bool): NimNode {.compileTime.} =
  ## Создаёт АСД с декларацией псевдометода.
  result = newProc(newIdentNode("pseudoMethod" & $stack &
                                (if swp:"S" else: ""))) # новая декларация пустой функции с именем "pseudoMethod<глубина стека>[S]"
  # подход с `quote` тут не работает, так как аргументы генерируются динамически
  result.addPragma(newIdentNode("cdecl")) # добавляем {.cdecl.}
  let nargs = max(int(stack div 4) - 1 - int(swp), 0) # число реальных аргументов за вычетом самого объекта и скрытого аргумента, если он есть
  let justargs = genArgs(nargs) # эта функция опущена, её результат - массив деклараций аргументов функции от "argument1: uint32" до "argument<nargs>: uint32"
  let origin = newIdentNode("origin")
  let rmethod = newIdentNode("rmethod")
  var mcall = genCall("rmethod", nargs) # эта функция тоже опущена, её результат - АСД вызова "rmethod(argument1, ... , argument<nargs>)"
  mcall.insert(1, origin) # вставка первым аргументом идентификатора оригинального объекта
  var argseq = @[ # Аргументы самого псевдометода
    newIdentNode("uint64"), # возвращаемое значение
    newIdentDefs(newIdentNode("methodNo"), newIdentNode("uint32")),
      # порядковый номер метода
    newIdentDefs(newIdentNode("obj"), newIdentNode("uint32")),
      # ссылка на объект (тип изменён на uint32 для простоты восприятия)
    newIdentDefs(newIdentNode("retAddress"), newIdentNode("uint32")),
      # адрес возврата
  ]
  if swp:
    # если есть скрытый аргумент - добавляем его
    argseq.add(newIdentDefs(newIdentNode("hidden"), newIdentNode("pointer")))
  # остальные аргументы добавляем в конец
  argseq &= justargs[1..^1]
  var originargs = @[ # Аргументы для декларации оригинального метода
    newIdentNode("uint64"),
    newIdentDefs(newIdentNode("obj"), newIdentNode("uint32")),
  ] & justargs[1..^1]
  let procty = newTree(nnkProcTy, newTree(nnkFormalParams, originargs),
                       newTree(nnkPragma, newIdentNode("cdecl"))) # сама декларация оригинального метода
  let args = newTree(nnkFormalParams, argseq)
  result[3] = args # подставляем аргументы в декларацию псевдометода
  let tracecall = genTraceCall(nargs) # реализация опущена для простоты, результат - вызов trace со всеми аргументами, переданными в псевдометод
  result.body = quote do: # подстановка тела функции
    trace("Method No %d was called for obj=%p and return to %p\n",
          methodNo, obj, retAddress)
    `tracecall`
    let wclass = cast[ptr WrappedClass](obj) # цена нашего упрощения декларации - необходимость преобразования `uint32` в `ptr WrappedClass`
    let `origin` = cast[uint32](wclass.origin)
    trace("Origin = %p\n", `origin`)
    let vtableaddr = wclass.origin.vtable
    trace("Origins VTable = %p\n", vtableaddr)
    let maddr = cast[ptr `procty`](cast[uint32](vtableaddr) + shift*4)
    trace("Method address to call: %p\n", maddr)
    let `rmethod` = maddr[]
    trace("Method to call: %p\n", `rmethod`)
  if swp:
    # для случая скрытого аргумента нужна ещё одна ассемблерная вставка, тут она показана не будет
    let asmcall = genAsmHiddenCall("rmethod", "origin", nargs) # вставка меняет местами скрытый аргумент и указатель на объект, а также исправляет стек так, что скрытый аргумент перестаёт быть скрытым
    result.body.add quote do:
      trace("Hidden before = %p (%p) \n", hidden, cast[ptr cint](hidden)[])
      `asmcall` # вызов происходит внутри вставки
      trace("Hidden result = %p (%p) \n", hidden, cast[ptr cint](hidden)[])
      return cast[uint64](hidden)
    # зато для случая скрытого аргумента не нужно выполнять проверку необходимости обёртки, заранее известно, что возвращаемое значение не является указателем на объект
  else:
    # добавляем АСД самого вызова и проверку необходимости обёртки
    result.body.add quote do:
      let res = `mcall`
      trace("Result = %p\n", res)
      return wrapIfNecessary(res) # реализация `wrapIfNecessary` в эту статью не поместилась

macro makeTableOfVTables(sink: untyped): untyped =
  # создаёт таблицу с массивами виртуальных методов каждого класса
  # `sink` - переменная-назначение, куда всё будет записано.
  result = newStmtList() # пустой список выражений
  result.add quote do: # `sink` в аргументах макроса указан как untyped, но в теле макроса он чудесным образом превращается в узел АСД, то есть имеет тип NimNode
    `sink` = initTable[string, seq[MethodProc]]() # создаём новую таблицу
  let classes = readClasses() # та самая функция readClasses, которой мы разбирали файл во время компиляции
  for k, v in classes.pairs:
    result.add(eachMethod(k, v, sink)) # сначала создаём методы-обёртки
  for i in declared: # напомню, что `declared` это глобальная переменная времени компиляции, по совместительству множество, которое мы определили и наполнили в eachMethod ранее.
    result.insert(0, makePseudoMethod(i, false)) # псевдометоды вставляем до самих методов, поскольку Nim, как и Си, чувствителен к порядку определения функций
  for i in swpdeclared:
    result.insert(0, makePseudoMethod(i, true))
  when declared(debug): # если компилятору передан флаг `-d:debug`, выводим АСД в виде кода в stdout прямо во время компиляции,
    echo(result.repr) # на случай если нужно будет посмотреть, как выглядит сгенерированный код
  # магия макроса превращает наш `result` из NimNode обратно в `untyped`, то есть в код
# и вызов макроса.
var vtables: Table[string, seq[MethodProc]]
makeTableOfVTables(vtables)

proc run(obj: ptr WrappedCallback, p: pointer) {.cdecl.} =
  # первый виртуальный метод класса CCallback.
  trace("[%p](%p)\n", obj, p)
  let originRun = (obj.origin.vtable + 0)[] # `+` определён отдельно для указателя и числа, чтобы избежать большого количества преобразований типов
  let originObj = obj.origin
  asm """
    mov %[obj], %%ecx # Метод игры ожидает увидеть указатель на объект в регистре ECX
    mov %%esp, %%edi # ESP сохраняем в EDI, т.к. он не меняется при вызове
    push %[p] # Помещаем аргумент в стек
    call %[mcall] # вызываем метод
    mov %%edi, %%esp # восстанавливаем стек
    ::[obj]"g"(`originObj`), [p]"g"(`p`), [mcall]"g"(`originRun`)
    :"eax", "edi", "ecx", "cc"
"""