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.freeIterator((char *)this, debugInfo);

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.free(*pStruct - 16, structSize + 16, &debugInfo);

} else {

context.free(*pStruct, structSize, &debugInfo);

}

*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.free(*pStruct, sizeOf, &debugInfo);

}

*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%s", errorMessage);

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[2];

} 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(nullptr, 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(&debugInfo, 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 DAS_NO_ASSERTIONS

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

#else

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

#endif

context.to_err(&debugInfo, error.c_str());

}

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

}

return v_zero();

DAS_PROFILE_NODE

auto pr = r->evalPtr(context); // right, then left

auto pl = l->evalPtr(context);

memcpy ( pl, pr, size );

return v_zero();

DAS_PROFILE_NODE

auto pr = r->evalPtr(context); // right, then left

auto pl = l->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 *));

for ( int t=int(totalSources)-1; t>=0; --t ) {

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

}

// 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:

closeIterators(sources.data(), pi.data(), context);

evalFinal(context);

context.stopFlags &= ~EvalFlags::stopForBreak;

return v_zero();

// 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:;

DAS_KEEPALIVE_LOOP(&context);

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:

closeIterators(sources.data(), pi.data(), context);

evalFinal(context);

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:

closeIterators(sources.data(), pi.data(), context);

this->evalFinal(context);

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) {

if ( context.gotoLabel>=totalLabels ) {

context.throw_error_at(debugInfo, "invalid label index %u", context.gotoLabel);

}

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 %u 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) {

if ( context.gotoLabel>=totalLabels ) {

context.throw_error_at(debugInfo, "invalid label index %u", context.gotoLabel);

}

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 %u 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

SimNode ** __restrict tail = list + total;

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

SimNode ** __restrict body = list;

loopbegin:;

DAS_KEEPALIVE_LOOP(&context);

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

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 ( 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);

});

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);

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

if ( persistent ) {

heap = make_smart<PersistentHeapAllocator>();

stringHeap = make_smart<PersistentStringAllocator>();

} else {

heap = make_smart<LinearHeapAllocator>();

stringHeap = make_smart<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) );

constStringHeap = make_shared<ConstStringAllocator>();

totalVariables = totalVars;

if ( globalStringHeapSize ) {

constStringHeap->setInitialSize(globalStringHeapSize);

}

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

globalsSize = 0;

sharedSize = 0;