{

lua_callbacks(L)->useratom =

[](lua_State*, const char* s, size_t l) -> int16_t {

auto itr = atoms.find(s);

if (itr != atoms.end())

{

return itr->second;

}

return -1;

};

const luaL_Reg* lib = lualibs;

for (; lib->func; lib++)

{

lua_pushcfunction(L, lib->func, NULL);

lua_pushstring(L, lib->name);

lua_call(L, 1, 0);

}

// Extend the buffer library with SIMD-accelerated functions

// (readf16, writef16, stridedcopy, convert).

luaopen_rive_buffer_ext(L);

return 0;

{

ScriptingContext* context =

static_cast<ScriptingContext*>(lua_getthreaddata(L));

context->printError(L);

// Optionally, you can push a new value onto the stack to be returned by

// lua_pcall For example, push a specific error code or a more detailed

// message

const char* error = lua_tostring(L, -1);

lua_pushstring(L, error);

return 1; // Number of return values

// return 0;

{

ScriptingContext* context =

static_cast<ScriptingContext*>(lua_getthreaddata(state));

int ret = context->pCall(state, nargs, nresults);

#ifdef RIVE_ORE

rive_lua_closeOrphanRenderPass(state);

#endif

return ret;

ScriptedObject* scriptedObject,

int nargs,

int nresults)

{

ScriptingContext* context =

static_cast<ScriptingContext*>(lua_getthreaddata(state));

ScopedScriptedObjectContext scope(context, scriptedObject);

int ret = context->pCall(state, nargs, nresults);

#ifdef RIVE_ORE

rive_lua_closeOrphanRenderPass(state);

#endif

return ret;

{

lua_checkstack(state, 1);

return lua_rawgeti(state, luaRegistryIndex, ref);

{

luaL_findtable(L, LUA_REGISTRYINDEX, registeredCacheTableKey, 1);

lua_getfield(L, -1, path);

if (lua_isnil(L, -1))

{

lua_pop(L, 2);

return 0;

}

lua_remove(L, -2);

return 1;

{

// Discard extra arguments, we only use path

lua_settop(L, 1);

const char* path = luaL_checkstring(L, 1);

if (checkRegisteredModules(L, path) == 1)

{

return 1;

}

// Record missing dependency if we're registering a module

if (requirerChunkname)

{

ScriptingContext* context =

static_cast<ScriptingContext*>(lua_getthreaddata(L));

if (context)

{

context->recordMissingDependency(requirerChunkname, path);

}

}

luaL_error(L, "require could not find a script named %s", path);

return 0;

{

lua_Debug ar;

int level = 1;

do

{

if (!lua_getinfo(L, level++, "s", &ar))

{

luaL_error(L, "require is not supported in this context");

}

} while (ar.what[0] == 'C');

return lua_requireinternal(L, ar.source);

{

int level = luaL_optinteger(L, 2, 1);

lua_settop(L, 1);

if (lua_isstring(L, 1) && level > 0)

{

luaL_where(L, level);

lua_pushvalue(L, 1);

lua_concat(L, 2);

}

lua_error(L);

{

lua_pushnil(L);

return 1;

{

luaopen_rive(state);

lua_setthreaddata(state, context);

lua_pushcclosurek(state, lua_require, "require", 0, nullptr);

lua_setglobal(state, "require");

lua_pushcclosurek(state, luaR_error, "error", 0, nullptr);

lua_setglobal(state, "error");

lua_pushcclosurek(state, lua_late, "late", 0, nullptr);

lua_setglobal(state, "late");

luaL_sandbox(state);

luaL_sandboxthread(state);

m_ownedContext(std::move(context))

{

m_state = lua_newstate(l_alloc, nullptr);

init(m_state, m_ownedContext.get());

{

if (m_state == nullptr)

{

return;

}

// Cancel async tasks before closing Lua state to prevent callbacks

// from accessing dead state.

if (m_ownedContext)

m_ownedContext->shutdownAsyncForState(m_state);

// Null every registered ScriptedObject's back-pointer before the lua

// teardown cascade. Once m_vm is gone, ScriptedObject::state() returns

// nullptr, so scriptDispose() (called from cascading destruction inside

// lua_close) skips its lua_unref / disposeScriptedContext calls. Those

// calls would otherwise dereference Lua userdatas (ScriptedContext, ref

// tables) that lua_close has already freed in earlier sweep iterations.

for (ScriptedObject* obj : m_scriptedObjects)

{

obj->m_vm = nullptr;

}

m_scriptedObjects.clear();

lua_State* state = m_state;

m_state = nullptr;

lua_close(state);

{

if (obj != nullptr)

{

m_scriptedObjects.insert(obj);

}

{

if (obj != nullptr)

{

m_scriptedObjects.erase(obj);

}

{

#ifdef WITH_RIVE_TOOLS

if (m_ownedContext != nullptr)

{

m_ownedContext->disposeOrphanScriptedProperties();

}

#endif

m_ownedContext = std::move(newContext);

lua_setthreaddata(m_state, m_ownedContext.get());

const char* name,

Span<uint8_t> bytecode)

{

if (bytecode.empty())

{

return false;

}

// module needs to run in a new thread, isolated from the rest

// note: we create ML on main thread so that it doesn't inherit environment

// of L

lua_State* GL = lua_mainthread(L);

lua_State* ML = lua_newthread(GL);

lua_xmove(GL, L, 1);

// new thread needs to have the globals sandboxed

luaL_sandboxthread(ML);

lua_setthreaddata(ML, lua_getthreaddata(L));

int status =

luau_load(ML, name, (const char*)bytecode.data(), bytecode.size(), 0);

if (status != 0)

{

// luau_load failed — error string is on ML stack

lua_xmove(ML, L, 1);

ScriptingContext* context =

static_cast<ScriptingContext*>(lua_getthreaddata(L));

context->printError(L);

lua_pop(L, 2); // pop error + thread

return false;

}

// Thread with loaded closure is on top of L's stack.

return true;

{

// The module thread should be on top of the stack.

lua_State* ML = lua_tothread(L, -1);

if (ML == nullptr)

{

return false;

}

int status = lua_resume(ML, L, 0);

if (status == 0)

{

if (lua_gettop(ML) == 0)

{

lua_pushfstring(ML, "%s:1: module must return a value", name);

}

else if (!lua_istable(ML, -1) && !lua_isfunction(ML, -1))

{

lua_pushfstring(ML,

"%s:1: module must return a table or function",

name);

}

}

else if (status == LUA_YIELD)

{

lua_pushfstring(ML, "%s:1: module can not yield", name);

}

else if (!lua_isstring(ML, -1))

{

lua_pushfstring(ML, "%s:1: unknown error while running module", name);

}

// add ML result to L stack

lua_xmove(ML, L, 1);

// An error occurred if the top of the stack is a string.

if (lua_isstring(L, -1))

{

ScriptingContext* context =

static_cast<ScriptingContext*>(lua_getthreaddata(L));

context->printError(L);

lua_pop(L, 2); // pop error + thread

return false;

}

// remove ML thread from L stack

lua_remove(L, -2);

// added one value to L stack: module result

if (isUtility)

{

// Register into the require cache directly.

luaL_findtable(L, LUA_REGISTRYINDEX, registeredCacheTableKey, 1);

lua_pushstring(L, name);

lua_pushvalue(L, -3); // copy module result (below cache table + name)

lua_settable(L, -3); // cache[name] = result

lua_pop(L, 1); // pop cache table

}

return true;

{

int i;

int top = lua_gettop(state);

for (i = 1; i <= top; i++)

{ /* repeat for each level */

int t = lua_type(state, i);

switch (t)

{

case LUA_TSTRING: /* strings */

fprintf(stderr,

" (%i)[STRING] %s\n",

i,

lua_tostring(state, i));

break;

case LUA_TBOOLEAN: /* booleans */

fprintf(stderr,

" (%i)[BOOLEAN] %s\n",

i,

lua_toboolean(state, i) ? "true" : "false");

break;

case LUA_TNUMBER: /* numbers */

fprintf(stderr,

" (%i)[NUMBER] %g\n",

i,

lua_tonumber(state, i));

break;

default: /* other values */

fprintf(stderr, " (%i)[%s]\n", i, lua_typename(state, t));

break;

}

}

fprintf(stderr, "\n"); /* end the listing */

{

m_modulesToRegister.push_back(moduleDetails);

m_moduleLookup[moduleDetails->moduleName()] = moduleDetails;

ModuleDetails* moduleDetails)

{

#ifndef WITH_RIVE_TOOLS

// In production builds, only allow verified (signed) scripts

if (!moduleDetails->verified())

{

return false;

}

#endif

const std::string& name = moduleDetails->moduleName();

bool registerSuccess = false;

int functionRef = 0;

if (moduleDetails->isProtocolScript())

{

if (ScriptingVM::registerScript(state,

name.c_str(),

moduleDetails->moduleBytecode()))

{

// registerScript leaves the function on the stack

if (static_cast<lua_Type>(lua_type(state, -1)) == LUA_TFUNCTION)

{

functionRef = lua_ref(state, -1);

}

lua_pop(state, 1);

registerSuccess = true;

}

}

else

{

if (ScriptingVM::registerModule(state,

name.c_str(),

moduleDetails->moduleBytecode()))

{

registerSuccess = true;

}

}

if (registerSuccess)

{

moduleDetails->registrationComplete(functionRef);

onModuleRegistered(moduleDetails);

return true;

}

return false;

{

// Loop over all of the modules once. We need do a tryRegister

// pass on each module in order to determine if it has any

// required dependencies

for (ModuleDetails* moduleDetails : m_modulesToRegister)

{

if (moduleDetails == nullptr)

{

continue;

}

std::string moduleName = moduleDetails->moduleName();

// Skip if already registered

if (checkRegisteredModules(state, moduleName.c_str()) == 1)

{

lua_pop(state, 1);

continue;

}

tryRegisterModule(state, moduleDetails);

}

// If any modules had dependencies, resolve their registration order

// and try registering again

if (!m_pendingModules.empty())

{

std::vector<ModuleDetails*> pendingModules;

for (auto module : m_pendingModules)

{

pendingModules.push_back(module);

}

std::vector<ModuleDetails*> sortedModules;

std::unordered_set<ModuleDetails*> visitedModules;

ModuleDetails* module = pendingModules.back();

pendingModules.pop_back();

sortNextModule(module,

&pendingModules,

&sortedModules,

&visitedModules);

// Register modules in sorted order

for (ModuleDetails* moduleDetails : sortedModules)

{

tryRegisterModule(state, moduleDetails);

}

}

m_modulesToRegister.clear();

m_pendingModules.clear();

ModuleDetails* module,

std::vector<ModuleDetails*>* pendingModules,

std::vector<ModuleDetails*>* sortedModules,

std::unordered_set<ModuleDetails*>* visitedModules)

{

// If already visited, skip

if (visitedModules->find(module) != visitedModules->end())

{

return;

}

auto dependencies = module->missingDependencies();

for (const auto& dependencyName : dependencies)

{

auto lookupIt = m_moduleLookup.find(dependencyName);

if (lookupIt != m_moduleLookup.end())

{

ModuleDetails* dependencyModule = lookupIt->second;

// Recursively process the dependency

sortNextModule(dependencyModule,

pendingModules,

sortedModules,

visitedModules);

}

}

if (std::find(sortedModules->begin(), sortedModules->end(), module) ==

sortedModules->end())

{

sortedModules->push_back(module);

}

visitedModules->insert(module);

if (!pendingModules->empty())

{

ModuleDetails* nextModule = pendingModules->back();

pendingModules->pop_back();

sortNextModule(nextModule,

pendingModules,

sortedModules,

visitedModules);

}

const std::string& requiringModule,

const std::string& missingModule)

{

if (!requiringModule.empty())

{

ModuleDetails* moduleDetails = m_moduleLookup[requiringModule];

if (moduleDetails != nullptr)

{

moduleDetails->addMissingDependency(missingModule);

m_pendingModules.insert(moduleDetails);

}

}

{

for (ModuleDetails* module : m_modulesToRegister)

{

if (!module->missingDependencies().empty())

{

moduleDetails->clearMissingDependency(moduleDetails->moduleName());

}

}

auto it = m_pendingModules.find(moduleDetails);

if (it != m_pendingModules.end())

{

m_pendingModules.erase(it);

}

std::vector<uint8_t> bytes)

{

m_shaderRstbs[std::move(name)] = std::move(bytes);

{

auto it = m_assetGeneratorRefs.find(assetId);

return it != m_assetGeneratorRefs.end() ? it->second : 0;

{

if (property != nullptr)

{

m_orphanScriptedProperties.push_back(property);

}

{

auto it = std::remove(m_orphanScriptedProperties.begin(),

m_orphanScriptedProperties.end(),

property);

m_orphanScriptedProperties.erase(it, m_orphanScriptedProperties.end());

{

auto orphans = m_orphanScriptedProperties;

for (ScriptedProperty* property : orphans)

{

if (property != nullptr)

{

property->dispose();

}

}

m_orphanScriptedProperties.clear();

{

if (m_ownerId != 0)

{