char ** value = (char **) _value;

if ( data != data_end ) {

*value = *data;

return true;

} else {

return false;

}

char ** value = (char **) _value;

if ( ++data != data_end ) {

*value = *data;

return true;

} else {

return false;

}

if ( _value ) {

char ** value = (char **) _value;

*value = nullptr;

}

context.heap->free((char *)this, size);

auto result = func(&context, context.abiArg, context.abiCMRES);

context.result = result;

return result;

char * THAT = (char *) this;

THAT -= offsetof(JitBlock, node);

auto block = (Block *) THAT;

auto ba = (BlockArguments *) ( context.stack.bottom() + block->argumentsOffset );

return func(&context, ba->arguments, ba->copyOrMoveResult, block );

DAS_PROFILE_NODE

auto pStruct = (char **) subexpr->evalPtr(context);

pStruct = pStruct + total - 1;

for ( uint32_t i=0, is=total; i!=is; ++i, pStruct-- ) {

if ( *pStruct ) {

if ( persistent ) {

das_aligned_free16(*pStruct);

} else if ( isLambda ) {

context.heap->free(*pStruct - 16, structSize + 16);

} else {

context.heap->free(*pStruct, structSize);

}

*pStruct = nullptr;

}

}

return v_zero();

DAS_PROFILE_NODE

auto pStruct = (char **) subexpr->evalPtr(context);

pStruct = pStruct + total - 1;

auto sizeOf = sizeexpr->evalInt(context);

for ( uint32_t i=0, is=total; i!=is; ++i, pStruct-- ) {

if ( *pStruct ) {

if (persistent) {

das_aligned_free16(*pStruct);

} else {

context.heap->free(*pStruct, sizeOf);

}

*pStruct = nullptr;

}

}

return v_zero();

DAS_PROFILE_NODE

auto pLambda = (Lambda *) subexpr->evalPtr(context);

pLambda = pLambda + total - 1;

for ( uint32_t i=0, is=total; i!=is; ++i, pLambda-- ) {

if ( pLambda->capture ) {

SimFunction ** fnMnh = (SimFunction **) pLambda->capture;

SimFunction * simFunc = fnMnh[1];

if (!simFunc) context.throw_error_at(debugInfo, "lambda finalizer is a null function");

vec4f argValues[1] = {

cast<void *>::from(pLambda->capture)

};

context.call(simFunc, argValues, 0);

pLambda->capture = nullptr;

}

}

return v_zero();

DAS_PROFILE_NODE

union {

vec4f res;

int32_t val[4];

} R, S;

S.res = value->eval(context);

R.val[0] = S.val[fields[0]];

R.val[1] = S.val[fields[1]];

R.val[2] = S.val[fields[2]];

R.val[3] = S.val[fields[3]];

return R.res;

DAS_PROFILE_NODE

union {

vec4f res;

int64_t val[4];

} R, S;

S.res = value->eval(context);

R.val[0] = S.val[fields[0]];

R.val[1] = S.val[fields[1]];

return R.res;

DAS_PROFILE_NODE

Block * block = (Block *) ( context.stack.sp() + stackTop );

block->stackOffset = context.stack.spi();

block->argumentsOffset = argStackTop ? (context.stack.spi() + argStackTop) : 0;

block->body = subexpr;

block->aotFunction = nullptr;

block->jitFunction = nullptr;

block->functionArguments = context.abiArguments();

block->info = info;

return cast<Block *>::from(block);

TextWriter ssw;

if ( message ) ssw << message << " ";

ssw << debug_type(typeInfo) << " = " << debug_value(res, typeInfo, PrintFlags::debugger)

<< " at " << FILE << ":" << LINE << "\n";

context->to_out(ssw.str().c_str());

DAS_PROFILE_NODE

FPE_DISABLE;

vec4f res = subexpr->eval(context);

TextWriter ssw;

if ( message ) ssw << message << " ";

ssw << debug_type(typeInfo) << " = " << debug_value(res, typeInfo, PrintFlags::debugger)

<< " at " << debugInfo.describe() << "\n";

context.to_out(ssw.str().c_str());

return res;

DAS_PROFILE_NODE

if ( !subexpr->evalBool(context) ) {

{

string error_message = "assert failed";

if ( message )

error_message = error_message + ", " + message;

string error = reportError(debugInfo, error_message, "", "");

#ifdef NDEBUG

error = context.getStackWalk(&debugInfo, false, false) + error;

#else

error = context.getStackWalk(&debugInfo, true, true) + error;

#endif

context.to_err(error.c_str());

}

context.throw_error_at(debugInfo,"assert failed");

}

return v_zero();

DAS_PROFILE_NODE

auto pl = l->evalPtr(context);

auto pr = r->evalPtr(context);

memcpy ( pl, pr, size );

return v_zero();

DAS_PROFILE_NODE

auto pl = l->evalPtr(context);

auto pr = r->evalPtr(context);

if ( pl != pr ) {

memcpy ( pl, pr, size );

memset ( pr, 0, size );

}

return v_zero();

totalSources = t;

auto bytes = code->allocate( totalSources * ( sizeof(SimNode*) + sizeof(uint32_t)*2 ) );

sources = (SimNode **) (bytes);

strides = (uint32_t *) (bytes + totalSources * sizeof(SimNode *));

stackTop = (uint32_t *) (bytes + totalSources * sizeof(SimNode *) + totalSources * sizeof(uint32_t));

totalSources = t;

auto bytes = code->allocate( totalSources * ( sizeof(SimNode*) + sizeof(uint32_t) ) );

source_iterators = (SimNode **) (bytes);

stackTop = (uint32_t *) (bytes + totalSources * sizeof(SimNode *));

// note: this is the 'slow' version, to which we fall back when there are too many sources

DAS_PROFILE_NODE

int totalCount = int(totalSources);

vector<char *> pi(totalCount);

for ( int t=0; t!=totalCount; ++t ) {

pi[t] = context.stack.sp() + stackTop[t];

}

vector<Iterator *> sources(totalCount);

for ( int t=0; t!=totalCount; ++t ) {

vec4f ll = source_iterators[t]->eval(context);

sources[t] = cast<Iterator *>::to(ll);

}

bool needLoop = true;

SimNode ** __restrict tail = list + total;

for ( int t=0; t!=totalCount; ++t ) {

sources[t]->isOpen = true;

needLoop = sources[t]->first(context, pi[t]) && needLoop;

if ( context.stopFlags ) goto loopend;

}

if ( !needLoop ) goto loopend;

while ( !context.stopFlags ) {

SimNode ** __restrict body = list;

loopbegin:;

for (; body!=tail; ++body) {

(*body)->eval(context);

DAS_PROCESS_LOOP_FLAGS(break);

}

for ( int t=0; t!=totalCount; ++t ){

if ( !sources[t]->next(context, pi[t]) ) goto loopend;

if ( context.stopFlags ) goto loopend;

}

}

loopend:

evalFinal(context);

for ( int t=0; t!=totalCount; ++t ) {

sources[t]->close(context, pi[t]);

}

context.stopFlags &= ~EvalFlags::stopForBreak;

return v_zero();

DAS_PROFILE_NODE

auto totalCount = int(totalSources);

vector<char *> pi(totalCount);

for ( int t=0; t!=totalCount; ++t ) {

pi[t] = context.stack.sp() + this->stackTop[t];

}

vector<Iterator *> sources(totalCount);

for ( int t=0; t!=totalCount; ++t ) {

vec4f ll = this->source_iterators[t]->eval(context);

sources[t] = cast<Iterator *>::to(ll);

}

bool needLoop = true;

SimNode ** __restrict tail = this-> list + this->total;

for ( int t=0; t!=totalCount; ++t ) {

sources[t]->isOpen = true;

needLoop = sources[t]->first(context, pi[t]) && needLoop;

if ( context.stopFlags ) goto loopend;

}

if ( !needLoop ) goto loopend;

while ( !context.stopFlags ) {

SimNode ** __restrict body = this->list;

loopbegin:;

for (; body!=tail; ++body) {

DAS_SINGLE_STEP(context,(*body)->debugInfo,true);

(*body)->eval(context);

DAS_PROCESS_LOOP_FLAGS(break);

}

for ( int t=0; t!=totalCount; ++t ){

if ( !sources[t]->next(context, pi[t]) ) goto loopend;

if ( context.stopFlags ) goto loopend;

}

}

loopend:

this->evalFinal(context);

for ( int t=0; t!=totalCount; ++t ) {

sources[t]->close(context, pi[t]);

}

context.stopFlags &= ~EvalFlags::stopForBreak;

return v_zero();

DAS_PROFILE_NODE

SimNode ** __restrict tail = list + total;

for (SimNode ** __restrict body = list; body!=tail; ++body) {

(*body)->eval(context);

if ( context.stopFlags ) break;

}

evalFinal(context);

return v_zero();

DAS_PROFILE_NODE

SimNode ** __restrict tail = list + total;

for (SimNode ** __restrict body = list; body!=tail; ++body) {

DAS_SINGLE_STEP(context,(*body)->debugInfo,false);

(*body)->eval(context);

if ( context.stopFlags ) break;

}

evalFinalSingleStep(context);

return v_zero();

DAS_PROFILE_NODE

SimNode ** __restrict tail = list + total;

for (SimNode ** __restrict body = list; body!=tail; ++body) {

(*body)->eval(context);

if ( context.stopFlags ) break;

}

return v_zero();

DAS_PROFILE_NODE

SimNode ** __restrict tail = list + total;

for (SimNode ** __restrict body = list; body!=tail; ++body) {

DAS_SINGLE_STEP(context,(*body)->debugInfo,false);

(*body)->eval(context);

if ( context.stopFlags ) break;

}

return v_zero();

DAS_PROFILE_NODE

SimNode ** __restrict tail = list + total;

for (SimNode ** __restrict body = list; body!=tail; ++body) {

(*body)->eval(context);

if ( context.stopFlags ) break;

}

evalFinal(context);

if ( context.stopFlags & EvalFlags::stopForReturn ) {

context.stopFlags &= ~EvalFlags::stopForReturn;

return context.abiResult();

} else {

if ( needResult ) context.throw_error_at(debugInfo,"end of block without return");

return v_zero();

}

DAS_PROFILE_NODE

SimNode ** __restrict tail = list + total;

for (SimNode ** __restrict body = list; body!=tail; ++body) {

DAS_SINGLE_STEP(context,(*body)->debugInfo,false);

(*body)->eval(context);

if ( context.stopFlags ) break;

}

evalFinalSingleStep(context);

if ( context.stopFlags & EvalFlags::stopForReturn ) {

context.stopFlags &= ~EvalFlags::stopForReturn;

return context.abiResult();

} else {

if ( needResult ) context.throw_error_at(debugInfo,"end of block without return");

return v_zero();

}

DAS_PROFILE_NODE

SimNode ** __restrict tail = list + total;

SimNode ** __restrict body = list;

loopbegin:;

for (; body!=tail; ++body) {

(*body)->eval(context);

{ if ( context.stopFlags ) {

if (context.stopFlags&EvalFlags::jumpToLabel && context.gotoLabel<totalLabels) {

body=list+labels[context.gotoLabel];

if ( body>=list && body<tail ) {

context.stopFlags &= ~EvalFlags::jumpToLabel;

goto loopbegin;

} else {

context.throw_error_at(debugInfo, "jump to label %i failed", context.gotoLabel);

}

}

goto loopend;

} }

}

loopend:;

evalFinal(context);

return v_zero();

DAS_PROFILE_NODE

SimNode ** __restrict tail = list + total;

SimNode ** __restrict body = list;

loopbegin:;

for (; body!=tail; ++body) {

DAS_SINGLE_STEP(context,(*body)->debugInfo,false);

(*body)->eval(context);

{ if ( context.stopFlags ) {

if (context.stopFlags&EvalFlags::jumpToLabel && context.gotoLabel<totalLabels) {

body=list+labels[context.gotoLabel];

if ( body>=list && body<tail ) {

context.stopFlags &= ~EvalFlags::jumpToLabel;

goto loopbegin;

} else {

context.throw_error_at(debugInfo, "jump to label %i failed", context.gotoLabel);

}

}

goto loopend;

} }

}

loopend:;

evalFinalSingleStep(context);

return v_zero();

DAS_PROFILE_NODE

for ( uint32_t i=0, is=total; i!=is && !context.stopFlags; ) {

list[i++]->eval(context);

}

return v_zero();

DAS_PROFILE_NODE

SimNode ** __restrict tail = list + total;

while ( cond->evalBool(context) && !context.stopFlags ) {

SimNode ** __restrict body = list;

loopbegin:;

for (; body!=tail; ++body) {

(*body)->eval(context);

DAS_PROCESS_LOOP_FLAGS(break);

}

}

loopend:;

evalFinal(context);

context.stopFlags &= ~EvalFlags::stopForBreak;

return v_zero();

DAS_PROFILE_NODE

SimNode ** __restrict tail = list + total;

while ( cond->evalBool(context) && !context.stopFlags ) {

SimNode ** __restrict body = list;

loopbegin:;

for (; body!=tail; ++body) {

DAS_SINGLE_STEP(context,(*body)->debugInfo,true);

(*body)->eval(context);

DAS_PROCESS_LOOP_FLAGS(break);

}

}

loopend:;

evalFinalSingleStep(context);

context.stopFlags &= ~EvalFlags::stopForBreak;

return v_zero();

DAS_PROFILE_NODE

if ( subexpr ) context.abiResult() = subexpr->eval(context);

context.stopFlags |= EvalFlags::stopForReturn;

return v_zero();

DAS_PROFILE_NODE

context.stopFlags |= EvalFlags::stopForReturn;

return v_zero();

DAS_PROFILE_NODE

context.abiResult() = value;

context.stopFlags |= EvalFlags::stopForReturn;

return v_zero();

DAS_PROFILE_NODE

context.abiResult() = cast<char *>::from(value);

context.stopFlags |= EvalFlags::stopForReturn;

return v_zero();

DAS_PROFILE_NODE

auto pl = context.abiCopyOrMoveResult();

DAS_ASSERT(pl);

auto pR = ((char **)(context.stack.sp() + stackTop));

*pR = pl;

subexpr->evalPtr(context);;

context.abiResult() = cast<char *>::from(pl);

context.stopFlags |= EvalFlags::stopForReturn;

return v_zero();

DAS_PROFILE_NODE

auto pr = subexpr->evalPtr(context);

auto pl = context.abiCopyOrMoveResult();

DAS_ASSERT(pl);

memcpy ( pl, pr, size);

context.abiResult() = cast<char *>::from(pl);

context.stopFlags |= EvalFlags::stopForReturn;

return v_zero();

DAS_PROFILE_NODE

auto pr = subexpr->evalPtr(context);

auto pl = context.abiCopyOrMoveResult();

DAS_ASSERT(pl);

if ( pl != pr ) {

memcpy ( pl, pr, size);

memset ( pr, 0, size);

}

context.abiResult() = cast<char *>::from(pl);

context.stopFlags |= EvalFlags::stopForReturn;

return v_zero();

DAS_PROFILE_NODE

char * ref = subexpr->evalPtr(context);

if ( context.stack.bottom()<=ref && ref<context.stack.sp()) {

context.throw_error_at(debugInfo,"reference bellow current function stack frame");

return v_zero();

}

#if DAS_ENABLE_STACK_WALK

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

auto top = context.stack.sp() + pp->info->stackSize;

if ( context.stack.sp()<=ref && ref<top ) {

context.throw_error_at(debugInfo,"reference to current function stack frame");

return v_zero();

}

#endif

context.abiResult() = cast<char *>::from(ref);

context.stopFlags |= EvalFlags::stopForReturn;

return v_zero();

DAS_PROFILE_NODE

auto ba = (BlockArguments *) ( context.stack.sp() + argStackTop );

auto pl = ba->copyOrMoveResult;

DAS_ASSERT(pl);

auto pR = ((char **)(context.stack.sp() + stackTop));

*pR = pl;

subexpr->evalPtr(context);;

context.abiResult() = cast<char *>::from(pl);

context.stopFlags |= EvalFlags::stopForReturn;

return v_zero();

DAS_PROFILE_NODE

auto pr = subexpr->evalPtr(context);

auto ba = (BlockArguments *) ( context.stack.sp() + argStackTop );

auto pl = ba->copyOrMoveResult;

memcpy ( pl, pr, size);

context.abiResult() = cast<char *>::from(pl);

context.stopFlags |= EvalFlags::stopForReturn;

return v_zero();

DAS_PROFILE_NODE

auto pr = subexpr->evalPtr(context);

auto ba = (BlockArguments *) ( context.stack.sp() + argStackTop );

auto pl = ba->copyOrMoveResult;

if ( pl != pr ) {

memcpy ( pl, pr, size);

memset ( pr, 0, size);

}

context.abiResult() = cast<char *>::from(pl);

context.stopFlags |= EvalFlags::stopForReturn;

return v_zero();

DAS_PROFILE_NODE

char * ref = subexpr->evalPtr(context);

if ( context.stack.bottom()<=ref && ref<context.stack.ap() ) {

context.throw_error_at(debugInfo,"reference bellow current call chain stack frame");

return v_zero();

}

context.abiResult() = cast<char *>::from(ref);

context.stopFlags |= EvalFlags::stopForReturn;

return v_zero();

DAS_PROFILE_NODE

SimNode ** __restrict tail = list + total;

SimNode ** __restrict body = list;

for (; body!=tail; ++body) {

(*body)->eval(context);

if (context.stopFlags) break;

}

context.abiResult() = cast<char *>::from(context.abiCopyOrMoveResult());

context.stopFlags |= EvalFlags::stopForReturn;

return v_zero();

if ( daScriptEnvironment::bound && daScriptEnvironment::bound->g_threadLocalDebugAgent.debugAgent ) {

lmbd ( daScriptEnvironment::bound->g_threadLocalDebugAgent.debugAgent );

}

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

for ( auto & it : g_DebugAgents ) {

lmbd ( it.second.debugAgent );

}

if ( daScriptEnvironment::bound && daScriptEnvironment::bound->g_threadLocalDebugAgent.debugAgent ) {

lmbd ( "", daScriptEnvironment::bound->g_threadLocalDebugAgent.debugAgent );

}

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

for ( auto & it : g_DebugAgents ) {

lmbd ( it.first, 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);

});

code = make_shared<NodeAllocator>();

constStringHeap = make_shared<ConstStringAllocator>();

debugInfo = make_shared<DebugInfoAllocator>();

ownStack = (stackSize != 0);

persistent = ph;

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;