mirror of
https://github.com/Dingo-Shenanigans/ReSkate.git
synced 2026-10-24 20:36:19 +02:00
AyeZeeBB
6d542536e1
A mod with a reskate-plugin.json is a plugin: Luau scripts that run in their own VM, with only
the reskate API ReSkate registers for them. Luau 0.741 is vendored in External/luau (the VM and
compiler only: no native code generation, no loadstring, io or C modules).
- Limits: 64 MB of memory, 50 ms a call, 2 ms a tick on average (over it for 3 s stops it),
more than 5 errors in 10 s stops it, 50 log lines a second. A plugin over a limit cannot catch
it in a pcall and carry on.
- API: reskate.log, on (load, unload, tick, level_loaded, level_unloading), timers, the level,
its own package's files and JSON, require inside the package; console.command and print
("console"); storage get, set, add and keys ("storage"), 1 MB in
%LOCALAPPDATA%\ReSkate\Plugins\<mod>\storage.json.
- Found every 2 s among the mods mods.json leaves on: switching a mod, or changing a plugin's
files, loads, unloads or reloads it without a restart. A package holding a program is refused.
- plugin list, commands, reload, off and on in the console. A plugin cannot take a name of
ReSkate's own commands.
- Tests: DINGOSDK_BUILD_PLUGIN_TESTS, including plugins written to break the sandbox.
70 lines
1.9 KiB
C++
70 lines
1.9 KiB
C++
// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
|
|
#pragma once
|
|
|
|
#include "Luau/BytecodeGraph.h"
|
|
|
|
#include <algorithm>
|
|
|
|
namespace Luau
|
|
{
|
|
|
|
namespace Bytecode
|
|
{
|
|
|
|
template<typename VmConst>
|
|
inline std::vector<BcOp>& usesOf(BcFunction<VmConst>& fn, const BcOp& def)
|
|
{
|
|
if (def.kind == BcOpKind::Inst)
|
|
return fn.instOp(def).uses;
|
|
else
|
|
{
|
|
LUAU_ASSERT(def.kind == BcOpKind::Phi);
|
|
return fn.phiOp(def).uses;
|
|
}
|
|
}
|
|
|
|
template<typename VmConst>
|
|
inline int countUses(BcFunction<VmConst>& fn, const BcOp& def, const BcOp& consumer)
|
|
{
|
|
std::vector<BcOp>& uses = usesOf(fn, def);
|
|
return static_cast<int>(std::count(uses.begin(), uses.end(), consumer));
|
|
}
|
|
|
|
template<typename VmConst>
|
|
inline bool hasUse(BcFunction<VmConst>& fn, const BcOp& def, const BcOp& consumer)
|
|
{
|
|
return countUses(fn, def, consumer) > 0;
|
|
}
|
|
|
|
// for every operand of every inst/phi in a live block, the referenced def must have that consumer in its `uses`
|
|
template<typename VmConst>
|
|
bool verifyUseConsistency(BcFunction<VmConst>& fn)
|
|
{
|
|
auto checkOperand = [&](const BcOp& consumer, BcOp operand)
|
|
{
|
|
if (operand.kind != BcOpKind::Inst && operand.kind != BcOpKind::Phi)
|
|
return true;
|
|
return hasUse(fn, operand, consumer);
|
|
};
|
|
|
|
bool result = true;
|
|
for (BcBlock& block : fn.blocks)
|
|
{
|
|
if ((block.flags & BcBlockFlag::Dead) != 0)
|
|
continue;
|
|
|
|
for (const BcOp& phiOp : block.phis)
|
|
for (const BcOp& operand : fn.phiOp(phiOp).ops)
|
|
result &= checkOperand(phiOp, operand);
|
|
|
|
for (const BcOp& instOp : block.ops)
|
|
for (const BcOp& operand : fn.instOp(instOp).ops)
|
|
result &= checkOperand(instOp, operand);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
} // namespace Bytecode
|
|
|
|
} // namespace Luau
|