Skip to main content

App - Scripting & Lua VM

ScriptContext, Lua-5.1 runtime integration, Luau bridge, and debugger.

Subsystem Metrics​

  • Total Documented Functions: 837
  • Functions Exercised in Tests: 69
  • Platform-Divergent Implementations: 48
  • Component Source Files: 37

Source Files​

View all 37 source files in this subsystem
Source FilePath
DebuggerManager.hApp/include/script/DebuggerManager.h
ExitHandlers.hApp/include/script/ExitHandlers.h
IScriptFilter.hApp/include/script/IScriptFilter.h
LuaArguments.hApp/include/script/LuaArguments.h
LuaAtomicClasses.hApp/include/script/LuaAtomicClasses.h
LuaEnum.hApp/include/script/LuaEnum.h
LuaInstanceBridge.hApp/include/script/LuaInstanceBridge.h
LuaLibrary.hApp/include/script/LuaLibrary.h
LuaSourceContainer.hApp/include/script/LuaSourceContainer.h
LuaVM.hApp/include/script/LuaVM.h
ModuleScript.hApp/include/script/ModuleScript.h
ScriptContext.hApp/include/script/ScriptContext.h
ScriptStats.hApp/include/script/ScriptStats.h
ThreadRef.hApp/include/script/ThreadRef.h
script.hApp/include/script/script.h
CoreScript.cppApp/script/CoreScript.cpp
DebuggerManager.cppApp/script/DebuggerManager.cpp
LuaArguments.cppApp/script/LuaArguments.cpp
LuaAtomicClasses.cppApp/script/LuaAtomicClasses.cpp
LuaCoreFunctions.cppApp/script/LuaCoreFunctions.cpp
LuaEnum.cppApp/script/LuaEnum.cpp
LuaInstanceBridge.cppApp/script/LuaInstanceBridge.cpp
LuaLibrary.cppApp/script/LuaLibrary.cpp
LuaMemory.cppApp/script/LuaMemory.cpp
LuaSignalBridge.cppApp/script/LuaSignalBridge.cpp
LuaSourceContainer.cppApp/script/LuaSourceContainer.cpp
LuaVM.cppApp/script/LuaVM.cpp
LuaVMClient.cppApp/script/LuaVMClient.cpp
LuaVMDummy.cppApp/script/LuaVMDummy.cpp
LuaVMServer.cppApp/script/LuaVMServer.cpp
ModuleScript.cppApp/script/ModuleScript.cpp
Script.cppApp/script/Script.cpp
ScriptAnalyzer.cppApp/script/ScriptAnalyzer.cpp
ScriptContext.cppApp/script/ScriptContext.cpp
ScriptEvent.cppApp/script/ScriptEvent.cpp
ScriptStats.cppApp/script/ScriptStats.cpp
ThreadRef.cppApp/script/ThreadRef.cpp

Function Reference​

1. ~ISpecialBreakpoint​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

virtual ~ISpecialBreakpoint();
PropertyValue
Return Typevirtual
ModifiersNone
Source LocationApp/include/script/DebuggerManager.h:36
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Declaration or inline method for ~ISpecialBreakpoint.

  • Control Flow & Execution: Linear execution flow.
  • Memory Management: Standard stack allocation.
  • Concurrency & Thread Safety: Unsynchronized / single-threaded context.
  • Error Handling & Invariants: Standard return value verification.
  • State Mutation: Stateless or local modification.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on ~ISpecialBreakpoint.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


2. getEnabled​

Status: 🧪 Tested  |  🌐 Cross-Platform Uniform

bool getEnabled() const;
PropertyValue
Return Typebool
Modifiersconst
Source LocationApp/include/script/DebuggerManager.h:81
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes getEnabled within App - Scripting & Lua VM.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).

How it is Used in Tests​

This function is exercised in 2 test case(s):

  • PostEffectTest::BlurEffectDefaults (App.UnitTest/PostEffectTest.cpp:13)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK(effect->getEnabled())
    • Callsite Snippet: BOOST_CHECK(effect->getEnabled());
  • SoundEffectTests::DistortionPropertiesAndParenting (App.UnitTest/SoundEffectTest.cpp:15)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK(effect->getEnabled())
    • Callsite Snippet: BOOST_CHECK(effect->getEnabled());

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


3. getBreakOnErrorMode​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

BreakOnErrorMode getBreakOnErrorMode() const;
PropertyValue
Return TypeBreakOnErrorMode
Modifiersconst
Source LocationApp/include/script/DebuggerManager.h:82
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes getBreakOnErrorMode within App - Scripting & Lua VM.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on getBreakOnErrorMode.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


4. getDebuggers​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

Debuggers& getDebuggers() const;
PropertyValue
Return TypeDebuggers&
Modifiersconst
Source LocationApp/include/script/DebuggerManager.h:87
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes getDebuggers within App - Scripting & Lua VM.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on getDebuggers.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


5. setScriptAutoResume​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void setScriptAutoResume(bool state);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationApp/include/script/DebuggerManager.h:110
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes setScriptAutoResume within App - Scripting & Lua VM.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on setScriptAutoResume.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


6. getScript​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

Instance* getScript() const;
PropertyValue
Return TypeInstance*
Modifiersconst
Source LocationApp/include/script/DebuggerManager.h:187
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes getScript within App - Scripting & Lua VM. Coordinates interactions with get.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: get.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on getScript.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


7. setIgnoreDebuggerBreak​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void setIgnoreDebuggerBreak(bool state);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationApp/include/script/DebuggerManager.h:195
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes setIgnoreDebuggerBreak within App - Scripting & Lua VM.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on setIgnoreDebuggerBreak.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


8. getBreakpoints​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

Breakpoints& getBreakpoints() const;
PropertyValue
Return TypeBreakpoints&
Modifiersconst
Source LocationApp/include/script/DebuggerManager.h:201
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes getBreakpoints within App - Scripting & Lua VM.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on getBreakpoints.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


9. getWatches​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

Watches& getWatches() const;
PropertyValue
Return TypeWatches&
Modifiersconst
Source LocationApp/include/script/DebuggerManager.h:209
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes getWatches within App - Scripting & Lua VM.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on getWatches.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


10. isDebugging​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

bool isDebugging() const;
PropertyValue
Return Typebool
Modifiersconst
Source LocationApp/include/script/DebuggerManager.h:218
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes isDebugging within App - Scripting & Lua VM. Coordinates interactions with empty.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: empty.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on isDebugging.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


11. hasError​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

bool hasError() const;
PropertyValue
Return Typebool
Modifiersconst
Source LocationApp/include/script/DebuggerManager.h:225
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes hasError within App - Scripting & Lua VM. Coordinates interactions with empty.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: empty.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on hasError.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


12. getCurrentLine​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

int getCurrentLine() const;
PropertyValue
Return Typeint
Modifiersconst
Source LocationApp/include/script/DebuggerManager.h:230
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes getCurrentLine within App - Scripting & Lua VM.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on getCurrentLine.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


13. getPausedThreads​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

PausedThreads& getPausedThreads() const;
PropertyValue
Return TypePausedThreads&
Modifiersconst
Source LocationApp/include/script/DebuggerManager.h:287
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes getPausedThreads within App - Scripting & Lua VM.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on getPausedThreads.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


14. isRootThreadResumed​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

bool isRootThreadResumed();
PropertyValue
Return Typebool
ModifiersNone
Source LocationApp/include/script/DebuggerManager.h:293
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes isRootThreadResumed within App - Scripting & Lua VM.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on isRootThreadResumed.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


15. getCurrentThread​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

long getCurrentThread();
PropertyValue
Return Typelong
ModifiersNone
Source LocationApp/include/script/DebuggerManager.h:296
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes getCurrentThread within App - Scripting & Lua VM.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on getCurrentThread.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


16. getLine​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

int getLine() const;
PropertyValue
Return Typeint
Modifiersconst
Source LocationApp/include/script/DebuggerManager.h:351
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes getLine within App - Scripting & Lua VM.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on getLine.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


17. isEnabled​

Status: ⚪ Untested in Suites  |  ⚠️ Platform Divergent

bool isEnabled() const;
PropertyValue
Return Typebool
Modifiersconst
Source LocationApp/include/script/DebuggerManager.h:353
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes isEnabled within App - Scripting & Lua VM.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on isEnabled.

Behavioral Differences Across Code Files​

Divergence Analysis: Alternative platform-specific implementations exist in: WindowsClient/GameVerbs.h, WindowsClient/GameVerbs.cpp.

  • Alternative Implementation Files: WindowsClient/GameVerbs.h, WindowsClient/GameVerbs.cpp

18. getCondition​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

std::string& getCondition() const;
PropertyValue
Return Typestd::string&
Modifiersconst const
Source LocationApp/include/script/DebuggerManager.h:355
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes getCondition within App - Scripting & Lua VM.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on getCondition.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


19. DebuggerWatch​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

public: DebuggerWatch();
PropertyValue
Return Typepublic:
ModifiersNone
Source LocationApp/include/script/DebuggerManager.h:379
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Declaration or inline method for DebuggerWatch.

  • Control Flow & Execution: Linear execution flow.
  • Memory Management: Standard stack allocation.
  • Concurrency & Thread Safety: Unsynchronized / single-threaded context.
  • Error Handling & Invariants: Standard return value verification.
  • State Mutation: Stateless or local modification.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on DebuggerWatch.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


20. getCondition​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

std::string& getCondition() const;
PropertyValue
Return Typestd::string&
Modifiersconst const
Source LocationApp/include/script/DebuggerManager.h:382
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes getCondition within App - Scripting & Lua VM.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on getCondition.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


21. getExpression​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

std::string& getExpression() const;
PropertyValue
Return Typestd::string&
Modifiersconst const
Source LocationApp/include/script/DebuggerManager.h:384
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes getExpression within App - Scripting & Lua VM.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on getExpression.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


22. empty​

Status: 🧪 Tested  |  🌐 Cross-Platform Uniform

bool empty() const;
PropertyValue
Return Typebool
Modifiersconst
Source LocationApp/include/script/ExitHandlers.h:19
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes empty within App - Scripting & Lua VM.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).

How it is Used in Tests​

This function is exercised in 6 test case(s):

  • LuaDebugger::FlatDataSerialization (App.UnitTest/LuaDebugger.cpp:139)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK(binaryDataStreamOriginal.str().empty() != true)
    • Callsite Snippet: BOOST_CHECK(binaryDataStreamOriginal.str().empty() != true);
  • LuaDebugger::NestedDataSerialization (App.UnitTest/LuaDebugger.cpp:211)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK(binaryDataStreamOriginal.str().empty() != true)
    • Callsite Snippet: BOOST_CHECK(binaryDataStreamOriginal.str().empty() != true);
  • URLParser::Split (App.UnitTest/URLParserTest.cpp:7)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK(url.query().empty())
    • Callsite Snippet: BOOST_CHECK(url.query().empty());
  • URLParser::Invalid (App.UnitTest/URLParserTest.cpp:128)
    • Usage Pattern: Direct Call
    • Assertions Checked: BOOST_CHECK(!url.isValid()), BOOST_CHECK_EQUAL(url.asString(), "")
    • Callsite Snippet: BOOST_CHECK(url.scheme().empty());

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


23. onRunTransition​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void onRunTransition(RunTransition event);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationApp/include/script/IScriptFilter.h:44
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes onRunTransition within App - Scripting & Lua VM. Coordinates interactions with onRunState.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: onRunState.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on onRunTransition.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


24. withVariantValue​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

R withVariantValue(const Reflection::Variant& value, F f);
PropertyValue
Return TypeR
ModifiersNone
Source LocationApp/include/script/LuaArguments.h:15
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Utility function that expands a variant to a strongly-typed value

  • Control Flow & Execution: Conditional branching, Explicit result return.
  • Memory Management: Reference-counted heap object ownership (boost::shared_ptr).
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Engine invariant assertion check (RBXASSERT); C++ exception throw on invalid state or failure; Standard runtime error exception formulation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: lookupDescriptor, type, lookup, runtime_error, c_str, RBXASSERT.
  • External Library Dependencies: G3D Graphics and Math Engine.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on withVariantValue.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


25. size​

Status: 🧪 Tested  |  ⚠️ Platform Divergent

size_t size() const;
PropertyValue
Return Typesize_t
Modifiersvirtual const
Source LocationApp/include/script/LuaArguments.h:150
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes size within App - Scripting & Lua VM. Coordinates interactions with lua_gettop.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: lua_gettop.

How it is Used in Tests​

This function is exercised in 59 test case(s):

  • Instance::LockUnlockDeprecated (App.UnitTest/Instance.cpp:186)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_REQUIRE_EQUAL(result->values.size(), 1)
    • Callsite Snippet: BOOST_REQUIRE_EQUAL(result->values.size(), 1);
  • WebSerializer::TestWebSerializerList (App.UnitTest/WebSerializerTest.cpp:12)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK(newValueCollection->size() == valueCollection->size())
    • Callsite Snippet: BOOST_CHECK(newValueCollection->size() == valueCollection->size());
  • WebSerializer::TestWebSerializerTable (App.UnitTest/WebSerializerTest.cpp:57)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK(newValueMap->size() == valueMap->size())
    • Callsite Snippet: BOOST_CHECK(newValueMap->size() == valueMap->size());
  • WebSerializer::TestWebSerializerInstance (App.UnitTest/WebSerializerTest.cpp:115)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK(newValue.get<shared_ptr<Instance> >()->getChildren()->size() == 3)
    • Callsite Snippet: BOOST_CHECK(newValue.get<shared_ptr<Instance> >()->getChildren()->size() == 3);

Behavioral Differences Across Code Files​

Divergence Analysis: Alternative platform-specific implementations exist in: XboxClient/p2p.h.

  • Alternative Implementation Files: XboxClient/p2p.h

26. getValues​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

shared_ptr<Reflection::Tuple> getValues(lua_State* L);
PropertyValue
Return Typeshared_ptr&lt;Reflection::Tuple&gt;
Modifiersstatic
Source LocationApp/include/script/LuaArguments.h:156
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Gets all arguments from the stack and puts them into the ValueArray

  • Control Flow & Execution: Iterative loop processing, Explicit result return.
  • Memory Management: Reference-counted heap object ownership (boost::shared_ptr).
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Engine invariant assertion check (RBXASSERT).
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: lua_gettop, args, get, RBXASSERT.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on getValues.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


27. pushTuple​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

int pushTuple(const Reflection::Tuple& arguments, lua_State* L);
PropertyValue
Return Typeint
Modifiersstatic
Source LocationApp/include/script/LuaArguments.h:171
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes pushTuple within App - Scripting & Lua VM. Coordinates interactions with pushValues.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: pushValues.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on pushTuple.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


28. pushValues​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

int pushValues(const Reflection::ValueArray& arguments, lua_State* L);
PropertyValue
Return Typeint
Modifiersstatic
Source LocationApp/include/script/LuaArguments.h:178
SubsystemApp - Scripting & Lua VM

How it Works Internally​

pushes all the values from the ValueArray onto the stack

  • Control Flow & Execution: Iterative loop processing, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: end, begin, push.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on pushValues.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


29. pushArray​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

int pushArray(_InIt _First, _InIt _Last, lua_State * const L);
PropertyValue
Return Typeint
Modifiersstatic
Source LocationApp/include/script/LuaArguments.h:228
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes pushArray within App - Scripting & Lua VM. Coordinates interactions with lua_createtable, push, RBXASSERT, lua_rawseti.

  • Control Flow & Execution: Iterative loop processing, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Engine invariant assertion check (RBXASSERT).
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: lua_createtable, push, RBXASSERT, lua_rawseti.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on pushArray.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


30. pushCoordinateFrame​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void pushCoordinateFrame(lua_State *L, const G3D::CoordinateFrame& CF);
PropertyValue
Return Typevoid
Modifiersstatic
Source LocationApp/include/script/LuaAtomicClasses.h:29
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes pushCoordinateFrame within App - Scripting & Lua VM. Coordinates interactions with pushNewObject.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: pushNewObject.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on pushCoordinateFrame.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


31. pushPhysicalProperties​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void pushPhysicalProperties(lua_State *L, const PhysicalProperties& v);
PropertyValue
Return Typevoid
Modifiersstatic
Source LocationApp/include/script/LuaAtomicClasses.h:62
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes pushPhysicalProperties within App - Scripting & Lua VM. Coordinates interactions with getCustomEnabled, pushNewObject, lua_pushnil.

  • Control Flow & Execution: Conditional branching.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: getCustomEnabled, pushNewObject, lua_pushnil.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on pushPhysicalProperties.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


32. pushRect2D​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void pushRect2D(lua_State *L, const G3D::Rect2D& v);
PropertyValue
Return Typevoid
Modifiersstatic
Source LocationApp/include/script/LuaAtomicClasses.h:84
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes pushRect2D within App - Scripting & Lua VM. Coordinates interactions with pushNewObject.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: pushNewObject.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on pushRect2D.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


33. pushRegion3​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void pushRegion3(lua_State *L, const RBX::Region3& v);
PropertyValue
Return Typevoid
Modifiersstatic
Source LocationApp/include/script/LuaAtomicClasses.h:99
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes pushRegion3 within App - Scripting & Lua VM. Coordinates interactions with pushNewObject.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: pushNewObject.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on pushRegion3.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


34. pushRegion3int16​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void pushRegion3int16(lua_State *L, const RBX::Region3int16& v);
PropertyValue
Return Typevoid
Modifiersstatic
Source LocationApp/include/script/LuaAtomicClasses.h:115
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes pushRegion3int16 within App - Scripting & Lua VM. Coordinates interactions with pushNewObject.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: pushNewObject.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on pushRegion3int16.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


35. pushVector3​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void pushVector3(lua_State *L, const G3D::Vector3& v);
PropertyValue
Return Typevoid
Modifiersstatic
Source LocationApp/include/script/LuaAtomicClasses.h:130
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes pushVector3 within App - Scripting & Lua VM. Coordinates interactions with pushNewObject.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: pushNewObject.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on pushVector3.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


36. pushVector3int16​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void pushVector3int16(lua_State *L, const G3D::Vector3int16& v);
PropertyValue
Return Typevoid
Modifiersstatic
Source LocationApp/include/script/LuaAtomicClasses.h:152
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes pushVector3int16 within App - Scripting & Lua VM. Coordinates interactions with pushNewObject.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: pushNewObject.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on pushVector3int16.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


37. pushRay​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void pushRay(lua_State *L, const RBX::RbxRay& v);
PropertyValue
Return Typevoid
Modifiersstatic
Source LocationApp/include/script/LuaAtomicClasses.h:172
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes pushRay within App - Scripting & Lua VM. Coordinates interactions with pushNewObject.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: pushNewObject.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on pushRay.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


38. pushVector2​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void pushVector2(lua_State *L, const RBX::Vector2& v);
PropertyValue
Return Typevoid
Modifiersstatic
Source LocationApp/include/script/LuaAtomicClasses.h:193
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes pushVector2 within App - Scripting & Lua VM. Coordinates interactions with pushNewObject.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: pushNewObject.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on pushVector2.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


39. pushVector2int16​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void pushVector2int16(lua_State *L, const RBX::Vector2int16& v);
PropertyValue
Return Typevoid
Modifiersstatic
Source LocationApp/include/script/LuaAtomicClasses.h:213
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes pushVector2int16 within App - Scripting & Lua VM. Coordinates interactions with pushNewObject.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: pushNewObject.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on pushVector2int16.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


40. pushUDim​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void pushUDim(lua_State *L, const RBX::UDim& v);
PropertyValue
Return Typevoid
Modifiersstatic
Source LocationApp/include/script/LuaAtomicClasses.h:258
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes pushUDim within App - Scripting & Lua VM. Coordinates interactions with pushNewObject.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: pushNewObject.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on pushUDim.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


41. pushCellID​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void pushCellID(lua_State *L, const CellID& v);
PropertyValue
Return Typevoid
Modifiersstatic
Source LocationApp/include/script/LuaAtomicClasses.h:327
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes pushCellID within App - Scripting & Lua VM. Coordinates interactions with pushNewObject.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: pushNewObject.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on pushCellID.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


42. pushNumberSequence​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void pushNumberSequence(lua_State* L, const NumberSequence& v);
PropertyValue
Return Typevoid
Modifiersstatic
Source LocationApp/include/script/LuaAtomicClasses.h:343
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes pushNumberSequence within App - Scripting & Lua VM. Coordinates interactions with pushNewObject.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: pushNewObject.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on pushNumberSequence.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


43. pushColorSequence​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void pushColorSequence(lua_State* L, const ColorSequence& v);
PropertyValue
Return Typevoid
Modifiersstatic
Source LocationApp/include/script/LuaAtomicClasses.h:355
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes pushColorSequence within App - Scripting & Lua VM. Coordinates interactions with pushNewObject.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: pushNewObject.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on pushColorSequence.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


44. pushNumberSequenceKeypoint​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void pushNumberSequenceKeypoint(lua_State* L, const NumberSequenceKeypoint& v);
PropertyValue
Return Typevoid
Modifiersstatic
Source LocationApp/include/script/LuaAtomicClasses.h:366
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes pushNumberSequenceKeypoint within App - Scripting & Lua VM. Coordinates interactions with pushNewObject.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: pushNewObject.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on pushNumberSequenceKeypoint.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


45. pushColorSequenceKeypoint​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void pushColorSequenceKeypoint(lua_State* L, const ColorSequenceKeypoint& v);
PropertyValue
Return Typevoid
Modifiersstatic
Source LocationApp/include/script/LuaAtomicClasses.h:377
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes pushColorSequenceKeypoint within App - Scripting & Lua VM. Coordinates interactions with pushNewObject.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: pushNewObject.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on pushColorSequenceKeypoint.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


46. pushNumberRange​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void pushNumberRange(lua_State* L, const NumberRange& v);
PropertyValue
Return Typevoid
Modifiersstatic
Source LocationApp/include/script/LuaAtomicClasses.h:388
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes pushNumberRange within App - Scripting & Lua VM. Coordinates interactions with pushNewObject.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: pushNewObject.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on pushNumberRange.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


47. getItem​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

EnumDescriptorItemPtr getItem(lua_State *L, unsigned int index);
PropertyValue
Return TypeEnumDescriptorItemPtr
Modifiersstatic
Source LocationApp/include/script/LuaEnum.h:35
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes getItem within App - Scripting & Lua VM. Coordinates interactions with getObject.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: getObject.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on getItem.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


48. getItem​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

bool getItem(lua_State *L, unsigned int index, EnumDescriptorItemPtr& value);
PropertyValue
Return Typebool
Modifiersstatic
Source LocationApp/include/script/LuaEnum.h:38
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes getItem within App - Scripting & Lua VM. Coordinates interactions with getValue.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: getValue.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on getItem.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


49. registerInstanceClassLibrary​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void registerInstanceClassLibrary(lua_State *L);
PropertyValue
Return Typevoid
Modifiersstatic
Source LocationApp/include/script/LuaInstanceBridge.h:18
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes registerInstanceClassLibrary within App - Scripting & Lua VM. Coordinates interactions with luaL_register, lua_setreadonly, lua_pop. Employs dynamic heap allocation via c++ operator new.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Dynamic heap allocation via C++ operator new.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: luaL_register, lua_setreadonly, lua_pop.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on registerInstanceClassLibrary.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


50. getInstance​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

boost::shared_ptr<Instance> getInstance(lua_State *L, unsigned int index);
PropertyValue
Return Typeboost::shared_ptr&lt;Instance&gt;
Modifiersstatic
Source LocationApp/include/script/LuaInstanceBridge.h:30
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes getInstance within App - Scripting & Lua VM. Coordinates interactions with getPtr.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: getPtr.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on getInstance.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


51. getLibraryName​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

std::string& getLibraryName() const;
PropertyValue
Return Typestd::string&
Modifiersconst const
Source LocationApp/include/script/LuaLibrary.h:13
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes getLibraryName within App - Scripting & Lua VM.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on getLibraryName.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


52. fireSourceChanged​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void fireSourceChanged();
PropertyValue
Return Typevoid
Modifiersvirtual
Source LocationApp/include/script/LuaSourceContainer.h:40
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Declaration or inline method for fireSourceChanged.

  • Control Flow & Execution: Linear execution flow.
  • Memory Management: Standard stack allocation.
  • Concurrency & Thread Safety: Unsynchronized / single-threaded context.
  • Error Handling & Invariants: Standard return value verification.
  • State Mutation: Stateless or local modification.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on fireSourceChanged.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


53. onScriptIdChanged​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void onScriptIdChanged();
PropertyValue
Return Typevoid
Modifiersvirtual
Source LocationApp/include/script/LuaSourceContainer.h:46
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Declaration or inline method for onScriptIdChanged.

  • Control Flow & Execution: Linear execution flow.
  • Memory Management: Standard stack allocation.
  • Concurrency & Thread Safety: Unsynchronized / single-threaded context.
  • Error Handling & Invariants: Standard return value verification.
  • State Mutation: Stateless or local modification.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on onScriptIdChanged.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


54. T​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

operator const T() const;
PropertyValue
Return Typeoperator const
Modifiersconst
Source LocationApp/include/script/LuaVM.h:50
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes T within App - Scripting & Lua VM. Coordinates interactions with return.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: return.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on T.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


55. double​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

operator const double() const;
PropertyValue
Return Typeoperator const
Modifiersconst
Source LocationApp/include/script/LuaVM.h:164
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes double within App - Scripting & Lua VM. Coordinates interactions with _mm_load_pd, _mm_load_sd, _mm_xor_pd, _mm_cvtsd_f64.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: _mm_load_pd, _mm_load_sd, _mm_xor_pd, _mm_cvtsd_f64.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on double.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


56. setReloadRequested​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void setReloadRequested(bool reload);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationApp/include/script/ModuleScript.h:79
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes setReloadRequested within App - Scripting & Lua VM.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on setReloadRequested.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


57. getReloadRequested​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

bool getReloadRequested() const;
PropertyValue
Return Typebool
Modifiersconst
Source LocationApp/include/script/ModuleScript.h:81
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes getReloadRequested within App - Scripting & Lua VM.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on getReloadRequested.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


58. update​

Status: 🧪 Tested  |  ⚠️ Platform Divergent

FORCEINLINE void update(const void* ptr);
PropertyValue
Return TypeFORCEINLINE void
ModifiersNone
Source LocationApp/include/script/ScriptContext.h:128
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes update within App - Scripting & Lua VM.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.

How it is Used in Tests​

This function is exercised in 1 test case(s):

  • HttpCacheEntryTest::CACHE_UPDATE_TEST (App.UnitTest/HttpCacheEntryTest.cpp:81)
    • Usage Pattern: Direct Call
    • Assertions Checked: BOOST_CHECK_EQUAL(200, result.getCacheHeader().responseCode), BOOST_CHECK_EQUAL(httpHeaders, result.getResponseHeader().toString())
    • Callsite Snippet: HttpPlatformImpl::Cache::CacheResult result = HttpPlatformImpl::Cache::CacheResult::update(NULL, url.c_str(), 200, headers, body);

Behavioral Differences Across Code Files​

Divergence Analysis: Behavior branches internally via conditional compilation for: Windows (Win32/x64 API). Alternative platform-specific implementations exist in: RobloxStudio/filewatcher/FileWatcherWin32.cpp.

  • Platform Preprocessor Guards: Windows (Win32/x64 API)
  • Alternative Implementation Files: RobloxStudio/filewatcher/FileWatcherWin32.cpp

59. checkAnchor​

Status: ⚪ Untested in Suites  |  ⚠️ Platform Divergent

FORCEINLINE bool checkAnchor(const void* ptr) const;
PropertyValue
Return TypeFORCEINLINE bool
Modifiersconst
Source LocationApp/include/script/ScriptContext.h:138
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Executes checkAnchor within App - Scripting & Lua VM.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on checkAnchor.

Behavioral Differences Across Code Files​

Divergence Analysis: Behavior branches internally via conditional compilation for: Windows (Win32/x64 API).

  • Platform Preprocessor Guards: Windows (Win32/x64 API)

60. state​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

: state(NotFetchedYet);
PropertyValue
Return Type:
ModifiersNone
Source LocationApp/include/script/ScriptContext.h:199
SubsystemApp - Scripting & Lua VM

How it Works Internally​

Declaration or inline method for state.

  • Control Flow & Execution: Linear execution flow.
  • Memory Management: Standard stack allocation.
  • Concurrency & Thread Safety: Unsynchronized / single-threaded context.
  • Error Handling & Invariants: Standard return value verification.
  • State Mutation: Stateless or local modification.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on state.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


Additional Functions

There are 777 additional internal and inline functions in this subsystem. All functions are indexed and cross-referenced in the Complete Function Catalog.