if ( g_envTotal > 0 && *daScriptEnvironment::g_threadLocalDebugAgent && (*daScriptEnvironment::g_threadLocalDebugAgent)->debugAgent ) {

lmbd ( (*daScriptEnvironment::g_threadLocalDebugAgent)->debugAgent );

}

std::lock_guard<std::recursive_mutex> guard(g_DebugAgentMutex);

for ( auto & it : g_DebugAgents ) {

if ( !it.second.debugAgent ) continue;

lmbd ( it.second.debugAgent );

}

for_each_debug_agent([&](const DebugAgentPtr & pAgent){

pAgent->onVariable(&ctx,category,name,(TypeInfo*)info,data);

});

for_each_debug_agent([&]( const DebugAgentPtr & pAgent ){

pAgent->onSimulateContext(&ctx);

});

if ( !command ) command = "";

bool any = false;

for_each_debug_agent([&]( const DebugAgentPtr & pAgent ){

if ( !any ) any = pAgent->onUserCommand(command);

});

for_each_debug_agent([&]( const DebugAgentPtr & pAgent ){

pAgent->onBeforeGC(&ctx);

});

for_each_debug_agent([&]( const DebugAgentPtr & pAgent ){

pAgent->onAfterGC(&ctx);

});

ref_count_magic = TRACK_PTR_CONTEXT;

code = make_shared<NodeAllocator>();

constStringHeap = make_shared<ConstStringAllocator>();

debugInfo = make_shared<DebugInfoAllocator>();

ownStack = (stackSize != 0);

persistent = ph;

verySafeContext = options.getBoolOption("very_safe_context",policies.very_safe_context);

breakOnException |= policies.debugger;

gcEnabled = options.getBoolOption("gc", false);

gcLogTime = options.getBoolOption("log_gc_time", policies.log_gc_time);

persistent = options.getBoolOption("persistent_heap", policies.persistent_heap);

if ( persistent ) {

heap = make_unique<PersistentHeapAllocator>();

stringHeap = make_unique<PersistentStringAllocator>();

} else {

heap = make_unique<LinearHeapAllocator>();

stringHeap = make_unique<LinearStringAllocator>();

}

heap->setInitialSize ( options.getIntOption("heap_size_hint", policies.heap_size_hint) );

heap->setLimit ( options.getUInt64OptionEx("heap_size_limit", "max_heap_allocated", policies.max_heap_allocated) );

stringHeap->setInitialSize ( options.getIntOption("string_heap_size_hint", policies.string_heap_size_hint) );

stringHeap->setLimit ( options.getUInt64OptionEx("string_heap_size_limit", "max_string_heap_allocated", policies.max_string_heap_allocated) );

bool track = options.getBoolOption("track_allocations", policies.track_allocations);

heap->setTrackAllocations(track);

stringHeap->setTrackAllocations(track);

constStringHeap = make_shared<ConstStringAllocator>();

totalVariables = totalVars;

if ( globalStringHeapSize ) {

constStringHeap->setInitialSize(globalStringHeapSize);

}

globalVariables = (GlobalVariable *) code->allocate( uint32_t(totalVars*sizeof(GlobalVariable)) );

globalsSize = 0;

sharedSize = 0;

stringHeap.reset();

heap.reset();

stack.strip();

if ( globals && globalsOwner ) {

das_aligned_free16(globals);

globals = nullptr;

}

if ( shared && sharedOwner ) {

das_aligned_free16(shared);

shared = nullptr;

}

uint64_t bytesTotal = 0, bytesUsed = 0;

// context

tw << "Context: 0x" << HEX << intptr_t(this) << DEC << " '" << name << "' use_count = " << use_count() << "\n";

bytesTotal = bytesUsed = sizeof(Context);

// stringHeap

if ( stringHeap ) {

tw << "\tstringHeap: " << stringHeap->bytesAllocated() << " of " << stringHeap->totalAlignedMemoryAllocated()

<< ", depth = " << stringHeap->depth() << "\n";

bytesTotal += stringHeap->totalAlignedMemoryAllocated();

bytesUsed += stringHeap->bytesAllocated();

}

// constStringHeap

if ( constStringHeap ) {

tw << "\tconstStringHeap: " << constStringHeap->bytesAllocated() << " of " << constStringHeap->totalAlignedMemoryAllocated()

<< ", depth = " << constStringHeap->depth() << "\n";

bytesTotal += constStringHeap->totalAlignedMemoryAllocated();

bytesUsed += constStringHeap->bytesAllocated();

}

// heap

if ( heap ) {

tw << "\theap: " << heap->bytesAllocated() << " of " << heap->totalAlignedMemoryAllocated()

<< ", depth = " << heap->depth() << "\n";

bytesTotal += heap->totalAlignedMemoryAllocated();

bytesUsed += heap->bytesAllocated();

}

// code

if ( code ) {

tw << "\tcode: " << code->bytesAllocated() << " of " << code->totalAlignedMemoryAllocated()

<< ", depth = " << code->depth() << "\n";

tw << "\t\ttableMN[" << tabMnLookup->size() << "]\n";

tw << "\t\ttableGMN[" << tabGMnLookup->size() << "]\n";

tw << "\t\ttableAd[" << tabAdLookup->size() << "]\n";

int aotf = 0;

for ( int i=0, is=totalFunctions; i!=is; ++i ) {

if ( functions[i].aotFunction ) aotf++;

}

if ( aotf>0 ) {

int64_t saot = int64_t(sizeof(SimNode_CallBase));

tw << "\tAOT " << aotf << " of " << totalFunctions << ", " << aotf << " x sizeof(SimNode_Aot = " << saot << ") = " << aotf*saot << "\n";

}

bytesTotal += code->totalAlignedMemoryAllocated();

bytesUsed += code->bytesAllocated();

}

// debugInfo

if ( debugInfo ) {

tw << "\tdebugInfo: " << debugInfo->bytesAllocated() << " of " << debugInfo->totalAlignedMemoryAllocated()

<< ", depth = " << debugInfo->depth() << "\n";

bytesTotal += debugInfo->totalAlignedMemoryAllocated();

bytesUsed += debugInfo->bytesAllocated();

}

// stack

if ( stack.bottom() ) {

tw << "\tstack: " << stack.size() << "\n";

bytesTotal += stack.size();

bytesUsed += stack.size();

}

// functions

//tw << "\functions table: " << totalFunctions*sizeof(SimFunction) << "\n";

//bytesTotal += totalFunctions*sizeof(SimFunction);

//bytesUsed += totalFunctions*sizeof(SimFunction);

// globals

//tw << "\tglobals table: " << totalVariables*sizeof(GlobalVariable) << "\n";

//bytesTotal += totalVariables*sizeof(GlobalVariable);

//bytesUsed += totalVariables*sizeof(GlobalVariable);

// globals data

if ( globals ) {

tw << "\tglobal data: " << globalsSize << "\n";

bytesTotal += globalsSize;

bytesUsed += globalsSize;

}

// shared

if ( shared ) {

tw << "\tshared data: " << sharedSize << "\n";

bytesTotal += sharedSize;

bytesUsed += sharedSize;

}

// total

tw << "-----------------------------------------------------------------\n";

tw << " total " << bytesTotal << ", wasted "

<< ((bytesTotal - bytesUsed)*100/bytesTotal) << "% ("

<< (bytesTotal - bytesUsed) << ")\n";

{

if (code == ctx.code)

return;

code = ctx.code;

constStringHeap = ctx.constStringHeap;

debugInfo = ctx.debugInfo;

thisProgram = ctx.thisProgram;

thisHelper = ctx.thisHelper;

category.value = ctx.category.value;

// globals (on condition that all context globals are read-only)

globals = ctx.globals;

globalsOwner = false;

annotationData = ctx.annotationData;

globalsSize = ctx.globalsSize;

globalInitStackSize = ctx.globalInitStackSize;

globalVariables = ctx.globalVariables;

totalVariables = ctx.totalVariables;

// shared

sharedSize = ctx.sharedSize;

shared = ctx.shared;

sharedOwner = false;

// functions

functions = ctx.functions;

totalFunctions = ctx.totalFunctions;

// mangled name table

tabMnLookup = ctx.tabMnLookup;

tabGMnLookup = ctx.tabGMnLookup;

tabAdLookup = ctx.tabAdLookup;

if ( globals && globalsOwner ) {

das_aligned_free16(globals);

globals = nullptr;

}

if ( shared && sharedOwner ) {

das_aligned_free16(shared);

shared = nullptr;

}

freeGlobalsAndShared();

globals = globalsSize ? (char *) das_aligned_alloc16(globalsSize) : nullptr;

shared = (sharedOwner && sharedSize) ? (char *) das_aligned_alloc16(sharedSize) : nullptr;

if ( shared ) memset(shared, 0, sharedSize);

globalsOwner = true;

sharedOwner = true;

uint64_t mem = 0;

mem += code ? code->totalAlignedMemoryAllocated() : 0;

mem += constStringHeap ? constStringHeap->totalAlignedMemoryAllocated() : 0;

mem += debugInfo ? debugInfo->totalAlignedMemoryAllocated() : 0;

mem += sharedSize;

return mem;

uint64_t mem = 0;

mem += globalsSize;

mem += stack.size();

mem += heap ? heap->totalAlignedMemoryAllocated() : 0;

mem += stringHeap ? stringHeap->totalAlignedMemoryAllocated() : 0;

return mem;

: stack(opts.stackSize ? opts.stackSize : ctx.stack.size()) {

ref_count_magic = TRACK_PTR_CONTEXT;

verySafeContext = ctx.verySafeContext;

persistent = ctx.persistent;

gcEnabled = ctx.gcEnabled;

code = ctx.code;

constStringHeap = ctx.constStringHeap;

debugInfo = ctx.debugInfo;

thisProgram = ctx.thisProgram;

thisHelper = ctx.thisHelper;

name = "clone of " + ctx.name;

category.value = opts.category;

skipInitShutdownScript = opts.skipInitScript;

ownStack = (ctx.stack.size() != 0);

if ( persistent ) {

heap = make_unique<PersistentHeapAllocator>();

stringHeap = make_unique<PersistentStringAllocator>();

} else {

heap = make_unique<LinearHeapAllocator>();

stringHeap = make_unique<LinearStringAllocator>();

}

// heap

heap->setInitialSize(ctx.heap->getInitialSize());

heap->setLimit(ctx.heap->getLimit());

heap->setTrackAllocations(ctx.heap->isTrackingAllocations());

stringHeap->setInitialSize(ctx.stringHeap->getInitialSize());

stringHeap->setIntern(ctx.stringHeap->isIntern());

stringHeap->setLimit(ctx.stringHeap->getLimit());

stringHeap->setTrackAllocations(ctx.stringHeap->isTrackingAllocations());

// globals

annotationData = ctx.annotationData;

globalsSize = ctx.globalsSize;

globalInitStackSize = ctx.globalInitStackSize;

globalVariables = ctx.globalVariables;

totalVariables = ctx.totalVariables;

if ( ctx.globals ) {

globals = (char *) (globalsSize ? das_aligned_alloc16(globalsSize) : nullptr);

}

// shared

sharedSize = ctx.sharedSize;

shared = ctx.shared;

sharedOwner = false;

// functoins

functions = ctx.functions;

totalFunctions = ctx.totalFunctions;

initFunctions = ctx.initFunctions;

totalInitFunctions = ctx.totalInitFunctions;

// mangled name table

tabMnLookup = ctx.tabMnLookup;

tabGMnLookup = ctx.tabGMnLookup;

tabAdLookup = ctx.tabAdLookup;

// jit init script

jitInitScript = ctx.jitInitScript;

// threadlock_context

if ( ctx.contextMutex ) contextMutex = new recursive_mutex;

// register

announceCreation();

// now, make it good to go

restart();

// a pure-data fork (skipInitScript) never touches globals, so skip the init script entirely

if ( !failed && !skipInitShutdownScript ) {

if ( stack.size() > globalInitStackSize ) {

failed |= !runWithCatch([&]() {

runInitScript();

});

} else {

auto ssz = max ( int(stack.size()), 16384 ) + globalInitStackSize;

StackAllocator init_stack(ssz);

SharedStackGuard init_guard(*this, init_stack);

failed |= !runWithCatch([&]() {

runInitScript();

});

}

if ( failed ) {

to_err(&exceptionAt, getException());

clearException();

}

}

restart();

if ( keepForkContexts.load(std::memory_order_relaxed) ) {

lock_guard<mutex> guard(forkContextPoolMutex);

forkContextPool.push_back(forkContext);

} else {

delete forkContext;

}

shared_ptr<NodeAllocator> newCode;

Context * context = nullptr;

int totalNodes = 0;

virtual SimNode * visit ( SimNode * node ) override {

totalNodes ++;

return node->copyNode(*context, newCode.get());

}

SimNodeRelocator rel;

rel.context = this;

rel.newCode = make_shared<NodeAllocator>();

rel.newCode->customGrow = [&](uint64_t ) { return uint64_t(4000); }; // because SimNode_Aot is 80 bytes

uint32_t codeSize = uint32_t(code->bytesAllocated());

if ( code->prefixWithHeader && !pwh ) {

// printf("[REL] %i adjusting\n", code->totalNodesAllocated);

codeSize -= code->totalNodesAllocated * uint32_t(sizeof(NodePrefix));

} else {

// printf("[REL] %i not adjusting\n", code->totalNodesAllocated);

}

rel.newCode->prefixWithHeader = pwh;

rel.newCode->setInitialSize(codeSize);

SimFunction * oldFunctions = functions;

if ( totalFunctions ) {

SimFunction * newFunctions = (SimFunction *) rel.newCode->allocate(totalFunctions*sizeof(SimFunction));

memcpy ( newFunctions, functions, totalFunctions*sizeof(SimFunction));

for ( int i=0, is=totalFunctions; i!=is; ++i ) {

newFunctions[i].name = rel.newCode->allocateName(functions[i].name);

newFunctions[i].mangledName = rel.newCode->allocateName(functions[i].mangledName);

}

functions = newFunctions;

}

if ( totalVariables ) {

GlobalVariable * newVariables = (GlobalVariable *) rel.newCode->allocate(totalVariables*sizeof(GlobalVariable));

memcpy ( newVariables, globalVariables, totalVariables*sizeof(GlobalVariable));

for ( int i=0, is=totalVariables; i!=is; ++i ) {

newVariables[i].name = rel.newCode->allocateName(globalVariables[i].name);

}

globalVariables = newVariables;

}

// relocate mangle-name lookup

for ( auto & kv : *tabMnLookup ) {

auto fn = kv.second;

if ( fn!=nullptr ) {

if ( fn>=oldFunctions && fn<(oldFunctions+totalFunctions) ) {

ptrdiff_t index = fn - oldFunctions;

kv.second = functions + index;

DAS_ASSERT(fn->mangledNameHash == kv.second->mangledNameHash);

DAS_ASSERT(kv.second>=functions && kv.second<(functions+totalFunctions));

// printf("%3i - MNH 0x%8x: %s [move %p -> %p]\n", i, fn->mangledNameHash, fn->name, fn, kv.second );

}

}

}

// relocate variables

if ( totalVariables ) {

for ( int j=0, js=totalVariables; j!=js; ++j ) {

auto & var = globalVariables[j];

if ( var.init) {

var.init = var.init->visit(rel);

}

}

}

// relocate functions

for ( int i=0, is=totalFunctions; i!=is; ++i ) {

auto & fn = functions[i];

fn.code = fn.code->visit(rel);

}

// swap the code

rel.newCode->totalNodesAllocated = rel.totalNodes;

// we need small repro of this happening. disabling the assert until i find one

// DAS_ASSERTF(rel.newCode->depth()<=1,"after code relocation all code should be on one page");

code = rel.newCode;

for_each_debug_agent([&](const DebugAgentPtr & pAgent){

pAgent->onCreateContext(this);

});

public:

virtual void beforeArray ( Array * pa, TypeInfo * ) override {

pa->shared = true;

}

virtual void beforeTable ( Table * pa, TypeInfo * ) override {

pa->shared = true;

}

DAS_ASSERTF(insideContext==0,"can't run init script on the locked context");

char * EP, *SP;

if(!stack.push(globalInitStackSize,EP,SP)) {

throw_error("stack overflow in the initialization script");

return;

}

vec4f args[2] = {

cast<void *>::from(this),

cast<bool>::from(sharedOwner) // only init shared if we are the owner

};

abiArg = args;

abiCMRES = nullptr;

if (globals) memset(globals, 0, globalsSize);

if ( aotInitScript ) {

aotInitScript->eval(*this);

} else if ( jitInitScript ) {

jitInitScript(this);

} else {

#if DAS_ENABLE_STACK_WALK

FuncInfo finfo;

memset(&finfo, 0, sizeof(finfo));

finfo.name = (char *) "Context::runInitScript";

// TODO: init arguments?

#endif

for ( int i=0, is=totalVariables; i!=is && !stopFlags; ++i ) {

auto & pv = globalVariables[i];

if ( pv.init ) {

if ( sharedOwner || !pv.shared ) {

#if DAS_ENABLE_STACK_WALK

finfo.stackSize = globalInitStackSize;

Prologue * pp = (Prologue *)stack.sp();

pp->info = &finfo;

pp->arguments = nullptr; // TODO: args

pp->cmres = nullptr;

pp->line = &pv.init->debugInfo;

#endif

pv.init->eval(*this);

#if DAS_ENABLE_STACK_WALK

pp->info = nullptr;

#endif

}

}

}

}

abiArg = nullptr;

stack.pop(EP,SP);

// run init functions

for ( int j=0, js=totalInitFunctions; j!=js && !stopFlags; ++j ) {

auto & pf = initFunctions[j];

callOrFastcall(pf, nullptr, 0);

}

// now, share the data

if ( sharedOwner && shared ) {

SharedDataWalker sdw;

for ( int i=0, is=totalVariables; i!=is; ++i ) {

auto & pv = globalVariables[i];

if ( pv.init && pv.shared ) {

sdw.walk(shared + pv.offset, pv.debugInfo);

}

}

}

DAS_ASSERTF(insideContext==0,"can't run init script on the locked context");

if ( shutdown ) return false;

shutdown = true;

auto ssz = 16384 + globalInitStackSize;

StackAllocator init_stack(ssz);

SharedStackGuard guard(*this, init_stack);

return runWithCatch([&](){

vector<SimFunction *> lateShutdown;

for ( int j=0, js=totalFunctions; j!=js && !stopFlags; ++j ) {

auto & pf = functions[j];

DAS_ASSERTF(pf.debugInfo, "Missing debug info for %s", pf.name);

if ( pf.debugInfo->flags & FuncInfo::flag_shutdown ) {

if ( pf.debugInfo->flags & FuncInfo::flag_late_shutdown ) {

lateShutdown.push_back(&pf);

} else {

callOrFastcall(&pf, nullptr, 0);

}

}

}

if ( !stopFlags && !lateShutdown.empty() ) {

for ( auto pf : lateShutdown ) {

callOrFastcall(pf, nullptr, 0);

if ( stopFlags ) break;

}

}

});

vector<SimFunction *> res;

for ( auto & kv : *tabMnLookup ) {

auto fn = kv.second;

if ( fn!=nullptr && strcmp(fn->name, fnname)==0 ) {

res.push_back(fn);

}

}

return res;

for ( int vni=0, vnis=totalVariables; vni!=vnis; ++vni ) {

if ( strcmp(globalVariables[vni].name, fnname)==0 ) {

return vni;

}

}

return -1;

public:

StackWalkerTextWriter ( TextWriter & tw, Context * ctx ) : ssw(tw), context(ctx) {}

virtual bool canWalkArguments () override {

return showArguments;

}

virtual bool canWalkVariables () override {

return showLocalVariables;

}

virtual bool canWalkOutOfScopeVariables() override {

return showOutOfScope;

}

virtual void onCallAOT ( Prologue *, const char * fileName ) override {

ssw << fileName << ", AOT";

}

virtual void onCallJIT ( Prologue *, const char * fileName ) override {

ssw << fileName << ", JIT";

}

virtual void onCallAt ( Prologue *, FuncInfo * info, LineInfo * at ) override {

ssw << info->name << " from " << at->describe();

}

virtual void onCall ( Prologue *, FuncInfo * info ) override {

ssw << info->name;

}

virtual void onAfterPrologue ( Prologue * pp, char * SP ) override {

ssw << "(sp=" << (context->stack.top() - SP)

<< ",sptr=0x" << HEX << intptr_t(SP) << DEC;

if ( pp->cmres ) {

ssw << ",cmres=0x" << HEX << intptr_t(pp->cmres) << DEC;

}

ssw << ")\n";

}

virtual void onArgument ( FuncInfo * info, int i, VarInfo * field, vec4f arg ) override {

ssw << "\t" << info->fields[i]->name

<< ": " << debug_type(field)

<< " = \t" << debug_value(arg, field, PrintFlags::stackwalker) << "\n";

}

virtual void onBeforeVariables ( ) override {

ssw << "--> local variables\n";

}

virtual void onVariable ( FuncInfo *, LocalVariableInfo * lv, void * addr, bool inScope ) override {

ssw << "\t" << lv->name

<< ": " << debug_type(lv);

string location;

if ( !inScope ) {

} else if ( lv->cmres ) {

location = "CMRES";

} else if ( lv->isRefValue( ) ) {

location = "ref *(sp + " + to_string(lv->stackTop) + ")";

} else {

location = "sp + " + to_string(lv->stackTop);

}

if ( addr ) {

ssw << " = \t" << debug_value(addr, lv, PrintFlags::stackwalker)

<< " at " << location

<< " 0x" << HEX << intptr_t(addr) << DEC

<< "\n";

} else {

if ( !inScope ) {

ssw << "\t// variable out of scope\n";

} else {

ssw << "\t// variable was optimized out\n";

}

}

}

virtual bool onAfterCall ( Prologue * ) override {

return !stackTopOnly;

}

virtual void onCorruptStack (Prologue * ) override {

ssw << "!!! stack corrupted, aborting stack walk !!!\n";

}

public:

bool showArguments = true;

bool showLocalVariables = true;

bool showOutOfScope = true;

bool stackTopOnly = false;

protected:

TextWriter & ssw;

Context * context;

FPE_DISABLE;

TextWriter ssw;

#if DAS_ENABLE_STACK_WALK

ssw << "\n";

if ( at ) {

ssw << "from " << at->describe() << "\n";

}

char * sp = stack.ap();

ssw << "CALL STACK (sp=" << (stack.top() - stack.ap())

<< ",sptr=0x" << HEX << intptr_t(sp) << DEC << "):\n";

StackWalkerTextWriter walker ( ssw, this );

walker.showArguments = showArguments;

walker.showLocalVariables = showLocalVariables;

walker.showOutOfScope = showOutOfScope;

walker.stackTopOnly = stackTopOnly;

dapiStackWalk ( &walker, *this, at ? *at : LineInfo() );

ssw << "\n";

#else

ssw << "\nCALL STACK TRACKING DISABLED:\n\n";

#endif

return ssw.str();

std::lock_guard<std::recursive_mutex> guard(g_DebugAgentMutex);

auto it = g_DebugAgents.find(name);

if ( it != g_DebugAgents.end() ) {

it->second.debugAgent->onTick();

}

for_each_debug_agent([&](const DebugAgentPtr & pAgent){

pAgent->onTick();

});

for_each_debug_agent([&](const DebugAgentPtr & pAgent){

pAgent->onCollect( &ctx, at );

});

for_each_debug_agent([&](const DebugAgentPtr & pAgent){

pAgent->onBreakpointsReset( file, breakpointsNum );

});

public:

virtual void onCreateContext ( Context * ctx ) override { if ( onCreateContextOp ) onCreateContextOp(ctx); }

virtual void onDestroyContext ( Context * ctx ) override { if ( onDestroyContextOp ) onDestroyContextOp(ctx); }

virtual bool onLog ( Context * context, const LineInfo * at, int level, const char * text ) override { return onLogOp ? onLogOp(context, at, level, text) : false; }

virtual bool isCppOnlyAgent() const override { return true; }

public:

function<void(Context*)> onCreateContextOp;

function<void(Context*)> onDestroyContextOp;

function<bool(Context *, const LineInfo *, int, const char *)> onLogOp;

std::lock_guard<std::recursive_mutex> guard(g_DebugAgentMutex);

auto it = g_DebugAgents.find(category);

CppOnlyDebugAgent * agent = nullptr;

if ( it != g_DebugAgents.end() ) {

DAS_VERIFY(it->second.debugAgent->isCppOnlyAgent());

agent = (CppOnlyDebugAgent *) it->second.debugAgent.get();

} else {

auto da = make_smart<CppOnlyDebugAgent>();

agent = (CppOnlyDebugAgent *) da.get();

g_DebugAgents[category] = {

nullptr,

da

};

}

lmb(agent);

onCppDebugAgent(category, [&](CppOnlyDebugAgent * agent){

agent->onCreateContextOp = das::move(lmb);

});

onCppDebugAgent(category, [&](CppOnlyDebugAgent * agent){

agent->onDestroyContextOp = das::move(lmb);

});

onCppDebugAgent(category, [&](CppOnlyDebugAgent * agent){

agent->onLogOp = das::move(lmb);

});

std::lock_guard<std::recursive_mutex> guard(g_DebugAgentMutex);

auto it = g_DebugAgents.find(category);

if ( it != g_DebugAgents.end() ) {

DebugAgentInstance inst = das::move(it->second);

g_DebugAgents.erase(it);

inst.debugAgent.reset(); // release agent before context

}

if ( !category ) context->throw_error_at(at, "need to specify category");

std::lock_guard<std::recursive_mutex> guard(g_DebugAgentMutex);

auto it = g_DebugAgents.find(category);

if ( it != g_DebugAgents.end() ) {

DebugAgent * oldAgentPtr = it->second.debugAgent.get();

for ( auto & ap : g_DebugAgents ) {

ap.second.debugAgent->onUninstall(oldAgentPtr);

}

DebugAgentInstance inst = das::move(it->second);

g_DebugAgents.erase(it);

inst.debugAgent.reset(); // release agent before context

}

if ( *daScriptEnvironment::g_threadLocalDebugAgent && (*daScriptEnvironment::g_threadLocalDebugAgent)->debugAgent ) {

context->throw_error_at(at, "thread local debug agent already installed");

}

std::lock_guard<std::recursive_mutex> guard(g_DebugAgentMutex);

(*daScriptEnvironment::g_threadLocalDebugAgent) = new DebugAgentInstance{

debugAgentContextOrNull(context),

newAgent

};

DebugAgent * newAgentPtr = newAgent.get();

for_each_debug_agent([newAgentPtr](DebugAgentPtr agent){

agent->onInstall(newAgentPtr);

});

if ( !category ) context->throw_error_at(at, "need to specify category");

std::lock_guard<std::recursive_mutex> guard(g_DebugAgentMutex);

auto it = g_DebugAgents.find(category);

if ( it != g_DebugAgents.end() ) {

DebugAgent * oldAgentPtr = it->second.debugAgent.get();

for_each_debug_agent([&](const DebugAgentPtr & pAgent){

pAgent->onUninstall(oldAgentPtr);

});

}

g_DebugAgents[category] = {

debugAgentContextOrNull(context),

newAgent

};

DebugAgent * newAgentPtr = newAgent.get();

for_each_debug_agent([&](const DebugAgentPtr & pAgent){

pAgent->onInstall(newAgentPtr);

});

if ( !category ) context->throw_error_at(at, "need to specify category");

std::lock_guard<std::recursive_mutex> guard(g_DebugAgentMutex);

auto it = g_DebugAgents.find(category);

return it != g_DebugAgents.end();

*g_isInDebugAgentCreation = true;

shared_ptr<Context> forkContext;

bool realPersistent = context->persistent;

context->persistent = true;

forkContext.reset(get_clone_context(context, uint32_t(ContextCategory::debug_context)));

context->persistent = realPersistent;

context->sharedPtrContext = true;

*g_isInDebugAgentCreation = false;

vec4f args[1];

args[0] = cast<Context *>::from(context);

SimFunction * fun = exFn.PTR;

forkContext->callOrFastcall(fun, args, lineinfo);

bool hasThreadLocal = *daScriptEnvironment::g_threadLocalDebugAgent && (*daScriptEnvironment::g_threadLocalDebugAgent)->debugAgent;

DebugAgent * threadLocalDebugAgent = hasThreadLocal ? (*daScriptEnvironment::g_threadLocalDebugAgent)->debugAgent.get() : nullptr;

for_each_debug_agent([&](const DebugAgentPtr & pAgent){

if ( hasThreadLocal ) {

threadLocalDebugAgent->onUninstall(pAgent.get());

}

for ( auto & ap : g_DebugAgents ) {

if ( ap.second.debugAgent ) {

ap.second.debugAgent->onUninstall(pAgent.get());

}