if ( expr->rtti_isVar() ) {

auto ev = static_pointer_cast<ExprVar>(expr);

return ev->local || !(ev->argument || ev->block);

} else if ( expr->rtti_isAt() ) {

auto ea = static_pointer_cast<ExprAt>(expr);

if ( ea->subexpr && ea->subexpr->type && ea->subexpr->type->dim.size() ) {

return isLocalOrGlobal(ea->subexpr);

}

} else if ( expr->rtti_isField() ) {

auto ef = static_pointer_cast<ExprField>(expr);

if ( ef->value && ef->value->type && (ef->value->type->baseType!=Type::tHandle || ef->value->type->isLocal()) ) {

return isLocalOrGlobal(ef->value);

}

} else if ( expr->rtti_isSwizzle() ) {

auto sw = static_pointer_cast<ExprSwizzle>(expr);

if ( sw->value ) {

return isLocalOrGlobal(sw->value);

}

}

return false;

tail = head;

head = this;

regFn = prfn;

auto it = head;

while ( it ) {

(*it->regFn)(lib);

it = it->tail;

}

TextWriter tw;

tw << "[" << annotation->getMangledName();

if (arguments.size()) {

tw << "(";

for (auto & arg : arguments) {

if (&arg != &arguments.front()) {

tw << ",";

}

tw << arg.name << ":" << das_to_string(arg.type) << "=";

switch (arg.type) {

case Type::tBool: tw << (arg.bValue ? "true" : "false"); break;

case Type::tInt: tw << arg.iValue; break;

case Type::tFloat: tw << arg.fValue; break;

case Type::tString: tw << "\"" << arg.sValue << "\""; break;

default: tw << "error"; break;

}

}

tw << ")";

}

tw << "]";

return tw.str();

switch (baseType) {

case Type::tInt8:

case Type::tUInt8:

return Type::tEnumeration8;

case Type::tInt16:

case Type::tUInt16:

return Type::tEnumeration16;

case Type::tInt:

case Type::tUInt:

return Type::tEnumeration;

default:

DAS_ASSERTF(0, "we should not be here. unsupported enumeration base type.");

return Type::none;

}

TypeDeclPtr res;

switch (baseType) {

case Type::tInt8:

case Type::tUInt8:

res = make_smart<TypeDecl>(Type::tEnumeration8); break;

case Type::tInt16:

case Type::tUInt16:

res = make_smart<TypeDecl>(Type::tEnumeration16); break;

case Type::tInt:

case Type::tUInt:

res = make_smart<TypeDecl>(Type::tEnumeration); break;

default:

DAS_ASSERTF(0, "we should not be here. unsupported enumeration base type.");

return nullptr;

}

res->enumType = const_cast<Enumeration*>(this);

return res;

auto it = find_if(list.begin(), list.end(), [&](const EnumEntry & arg){

return arg.name == na;

});

return it!=list.end() ?

pair<ExpressionPtr,bool>(it->value,true) :

pair<ExpressionPtr,bool>(nullptr,false);

auto it = find_if(list.begin(), list.end(), [&](const EnumEntry & arg){

return arg.name == na;

});

return it!=list.end() ? getConstExprIntOrUInt(it->value) : def;

for ( const auto & it : list ) {

if ( getConstExprIntOrUInt(it.value)==va ) {

return it.name;

}

}

return def;

auto it = find_if(list.begin(), list.end(), [&](const EnumEntry & arg){

return arg.name == na;

});

if ( it == list.end() ) {

EnumEntry ena;

ena.name = na;

ena.cppName = naCpp.empty() ? na : naCpp;

ena.value = expr;

ena.at = att;

list.push_back(ena);

return true;

} else {

return false;

}

auto cs = make_smart<Structure>(name);

cs->fields.reserve(fields.size());

for ( auto & fd : fields ) {

cs->fields.emplace_back(fd.name, fd.type, fd.init, fd.annotation, fd.moveSemantics, fd.at);

cs->fields.back().flags = fd.flags;

}

cs->at = at;

cs->module = module;

cs->flags = flags;

cs->annotations = cloneAnnotationList(annotations);

return cs;

if ( castS.fields.size() < fields.size() ) {

return false;

}

for ( size_t i=0; i!=fields.size(); ++i ) {

auto & fd = fields[i];

auto & cfd = castS.fields[i];

if ( fd.name != cfd.name ) {

return false;

}

if ( !fd.type->isSameType(*cfd.type, RefMatters::yes, ConstMatters::yes, TemporaryMatters::yes) ) {

return false;

}

}

return true;

for ( const auto & fd : fields ) {

if ( fd.init ) return true;

}

return false;

for ( const auto & fd : fields ) {

if ( !fd.type->canCopy(tempMatters) )

return false;

}

return true;

for ( const auto & fd : fields ) {

if ( !fd.type->canMove() )

return false;

}

return true;

for ( const auto & fd : fields ) {

if ( !fd.type->canClone() )

return false;

}

return true;

for ( const auto & fd : fields ) {

if ( !fd.type->canAot(recAot) )

return false;

}

return true;

for ( const auto & fd : fields ) {

if ( !fd.type->isNoHeapType() )

return false;

}

return true;

for ( const auto & fd : fields ) {

if ( !fd.type->isPod() )

return false;

}

return true;

for ( const auto & fd : fields ) {

if ( !fd.type->isRawPod() )

return false;

}

return true;

int size = 0;

const Structure * cppLayoutParent = nullptr;

for ( const auto & fd : fields ) {

int fieldAlignemnt = fd.type->getAlignOf();

int al = fieldAlignemnt - 1;

if ( cppLayout ) {

auto fp = findFieldParent(fd.name);

if ( fp!=cppLayoutParent ) {

if (DAS_NON_POD_PADDING || !cppLayoutNotPod) {

size = cppLayoutParent ? cppLayoutParent->getSizeOf() : 0;

}

cppLayoutParent = fp;

}

}

size = (size + al) & ~al;

size += fd.type->getSizeOf();

}

int al = getAlignOf() - 1;

size = (size + al) & ~al;

return size;

int align = 1;

for ( const auto & fd : fields ) {

align = das::max ( fd.type->getAlignOf(), align );

}

return align;

for ( const auto & fd : fields ) {

if ( fd.type && !fd.type->canBePlacedInContainer(dep) ) {

return false;

}

}

return true;

for ( const auto & fd : fields ) {

if ( fd.type && !fd.type->hasNonTrivialCtor(dep) ) {

return false;

}

}

return true;

for ( const auto & fd : fields ) {

if ( fd.type && !fd.type->hasNonTrivialDtor(dep) ) {

return false;

}

}

return true;

for ( const auto & fd : fields ) {

if ( fd.type && !fd.type->hasNonTrivialCopy(dep) ) {

return false;

}

}

return true;

for ( const auto & fd : fields ) {

if ( fd.type && fd.type->isExprTypeAnywhere(dep) ) {

return true;

}

}

return false;

for ( const auto & fd : fields ) {

if ( fd.type && !fd.type->isLocal(dep) ) {

return false;

}

}

return true;

if ( isClass ) return true;

for ( const auto & fd : fields ) {

if ( fd.type && fd.type->hasClasses(dep) ) {

return true;

}

}

return false;

for ( const auto & fd : fields ) {

if ( fd.type && fd.type->isTemp(true, true, dep) ) {

return true;

}

}

return false;

for ( const auto & fd : fields ) {

if ( fd.type && !fd.type->isShareable(dep) ) {

return false;

}

}

return true;

auto pVar = make_smart<Variable>();

pVar->name = name;

pVar->aka = aka;

pVar->type = make_smart<TypeDecl>(*type);

if ( init )

pVar->init = init->clone();

if ( source )

pVar->source = source->clone();

pVar->at = at;

pVar->flags = flags;

pVar->initStackSize = initStackSize;

pVar->annotation = annotation;

return pVar;

if ( !init ) {

return false;

}

if ( !type->hasNonTrivialCtor() ) {

return false;

}

if ( init->rtti_isCallFunc() ) {

auto cfun = static_pointer_cast<ExprCallFunc>(init);

if ( cfun->func && cfun->func->isTypeConstructor ) {

return true;

}

}

return false;

AnnotationList clist;

for ( auto & ann : list ) {

auto decl = make_smart<AnnotationDeclaration>();

decl->annotation = ann->annotation;

decl->arguments = ann->arguments;

decl->at = ann->at;

clist.push_back(decl);

}

return clist;

auto cfun = make_smart<Function>();

cfun->name = name;

for ( const auto & arg : arguments ) {

cfun->arguments.push_back(arg->clone());

}

cfun->annotations = cloneAnnotationList(annotations);

cfun->result = make_smart<TypeDecl>(*result);

cfun->body = body->clone();

cfun->index = -1;

cfun->totalStackSize = 0;

cfun->totalGenLabel = totalGenLabel;

cfun->at = at;

cfun->atDecl = atDecl;

cfun->module = nullptr;

cfun->flags = flags;

cfun->moreFlags = moreFlags;

cfun->sideEffectFlags = sideEffectFlags;

cfun->inferStack = inferStack;

cfun->classParent = classParent;

return cfun;

if ( !inferStack.size() ) {

return "";

}

TextWriter ss;

ss << "\nwhile compiling " << describe() << "\n";

for ( const auto & ih : inferStack ) {

ss << "instanced from " << ih.func->describe() << " at " << ih.at.describe() << "\n";

}

return ss.str();

TextWriter ss;

if ( moduleName==DescribeModule::yes && module && !module->name.empty() ) {

ss << module->name << "::";

}

if ( !isalpha(name[0]) && name[0]!='_' && name[0]!='`' ) {

ss << "operator ";

}

ss << name;

return ss.str();

TextWriter ss;

if ( moduleName==DescribeModule::yes && module && !module->name.empty() ) {

ss << module->name << "::";

}

if ( !isalpha(name[0]) && name[0]!='_' && name[0]!='`' ) {

ss << "operator ";

}

ss << name;

if ( arguments.size() ) {

ss << " ( ";

for ( auto & arg : arguments ) {

ss << arg->name << " : " << *arg->type;

if ( extra==DescribeExtra::yes && arg->init ) {

ss << " = " << *arg->init;

}

if ( arg != arguments.back() ) ss << "; ";

}

ss << " )";

}

ss << " : " << result->describe();

return ss.str();

FixedBufferTextWriter ss;

getMangledName(ss);

return ss.str();

if ( module && !module->name.empty() ) {

ss << "@" << module->name << "::";

}

ss << name;

for ( auto & arg : arguments ) {

ss << " ";

arg->type->getMangledName(ss);

}

for ( auto & arg : arguments ) {

if ( arg->name==na ) {

return arg;

}

}

return nullptr;

vis.preVisit(this);

for ( auto & arg : arguments ) {

vis.preVisitArgument(this, arg, arg==arguments.back() );

if ( arg->type ) {

vis.preVisit(arg->type.get());

arg->type = arg->type->visit(vis);

arg->type = vis.visit(arg->type.get());

}

if ( arg->init && vis.canVisitArgumentInit(this,arg,arg->init.get()) ) {

vis.preVisitArgumentInit(this, arg, arg->init.get());

arg->init = arg->init->visit(vis);

if ( arg->init ) {

arg->init = vis.visitArgumentInit(this, arg, arg->init.get());

}

}

arg = vis.visitArgument(this, arg, arg==arguments.back() );

}

if ( result ) {

vis.preVisit(result.get());

result = result->visit(vis);

result = vis.visit(result.get());

}

if ( body ) {

vis.preVisitFunctionBody(this, body.get());

if ( body ) body = body->visit(vis);

if ( body ) body = vis.visitFunctionBody(this, body.get());

}

return vis.visit(this);

for ( const auto & ann : annotations ) {

if (ann->annotation) {

auto fna = static_pointer_cast<FunctionAnnotation>(ann->annotation);

if (fna->isGeneric()) {

return true;

}

}

}

for ( auto & arg : arguments ) {

if ( arg->type->isAuto() && !arg->init ) {

return true;

}

}

return false;

for ( auto & ann : annotations ) {

if ( ann->annotation->rtti_isFunctionAnnotation() ) {

auto pAnn = static_pointer_cast<FunctionAnnotation>(ann->annotation);

return pAnn->aotArgumentPrefix(call, argIndex);

}

}

return "";

for ( auto & ann : annotations ) {

if ( ann->annotation->rtti_isFunctionAnnotation() ) {

auto pAnn = static_pointer_cast<FunctionAnnotation>(ann->annotation);

return pAnn->aotArgumentSuffix(call, argIndex);

}

}

return "";

for ( auto & ann : annotations ) {

if ( ann->annotation->rtti_isFunctionAnnotation() ) {

auto pAnn = static_pointer_cast<FunctionAnnotation>(ann->annotation);

return pAnn->aotName(call);

}

}

return call->func->getAotBasicName();

sideEffectFlags = uint32_t(seFlags) & ~uint32_t(SideEffects::unsafe);

if ( uint32_t(seFlags) & uint32_t(SideEffects::unsafe) ) {

unsafeOperation = true;

}

return this;

builtIn = true;

name = fn;

cppName = fnCpp ? fnCpp : "";

this->totalStackSize = sizeof(Prologue);

for ( size_t argi=1; argi != args.size(); ++argi ) {

auto arg = make_smart<Variable>();

arg->name = "arg" + to_string(argi-1);

arg->type = args[argi];

if ( arg->type->baseType==Type::fakeContext ) {

arg->init = make_smart<ExprFakeContext>(at);

arg->init->generated = true;

} else if ( arg->type->baseType==Type::fakeLineInfo ) {

arg->init = make_smart<ExprFakeLineInfo>(at);

arg->init->generated = true;

}

if ( arg->type->isTempType() ) {

arg->type->implicit = true;

}

this->arguments.push_back(arg);

}

result = args[0];

if ( result->isRefType() && !result->ref ) {

if ( result->canCopy() ) {

copyOnReturn = true;

moveOnReturn = false;

} else if ( result->canMove() ) {

copyOnReturn = false;

moveOnReturn = true;

} else if ( result->ref ) {

// its ref, so its fine

} else if ( result->hasNonTrivialCtor() ) {

// we can initialize it locally

} else {

DAS_FATAL_ERROR("BuiltInFn %s can't be bound. It returns values which can't be copied or moved\n", name.c_str());

}

} else {

copyOnReturn = false;

moveOnReturn = false;

}

this->totalStackSize = sizeof(Prologue);

for ( size_t argi=1; argi != args.size(); ++argi ) {

auto arg = make_smart<Variable>();

arg->name = "arg" + to_string(argi-1);

arg->type = args[argi];

if ( arg->type->baseType==Type::fakeContext ) {

arg->init = make_smart<ExprFakeContext>(at);

arg->init->generated = true;

} else if ( arg->type->baseType==Type::fakeLineInfo ) {

arg->init = make_smart<ExprFakeLineInfo>(at);

arg->init->generated = true;

}

this->arguments.push_back(arg);

}

result = args[0];

if ( result->isRefType() && !result->ref ) {

if ( result->canCopy() ) {

copyOnReturn = true;

moveOnReturn = false;

} else if ( result->canMove() ) {

copyOnReturn = false;

moveOnReturn = true;

} else if ( !result->ref ) {

DAS_FATAL_ERROR("ExternalFn %s can't be bound. It returns values which can't be copied or moved\n", name.c_str());

}

} else {

copyOnReturn = false;

moveOnReturn = false;

}

this->totalStackSize = sizeof(Prologue);

for ( size_t argi=1; argi!=args.size(); ++argi ) {

auto arg = make_smart<Variable>();

arg->name = "arg" + to_string(argi-1);

arg->type = args[argi];

if ( arg->type->baseType==Type::fakeContext ) {

arg->init = make_smart<ExprFakeContext>(at);

arg->init->generated = true;

} else if ( arg->type->baseType==Type::fakeLineInfo ) {

arg->init = make_smart<ExprFakeLineInfo>(at);

arg->init->generated = true;

}

this->arguments.push_back(arg);

}

result = args[0];

if ( result->isRefType() && !result->ref ) {

if ( result->canCopy() ) {

copyOnReturn = true;

moveOnReturn = false;

} else if ( result->canMove() ) {

copyOnReturn = false;

moveOnReturn = true;

} else if ( !result->ref ) {

DAS_FATAL_ERROR("InteropFn %s can't be bound. It returns values which can't be copied or moved\n", name.c_str());

}

} else {

copyOnReturn = false;

moveOnReturn = false;

}

if (!isCmres) {

if (fnX->result->isRefType() && !fnX->result->ref) {

DAS_FATAL_ERROR(

"addExtern(%s)::failed in module %s\n"

" this function should be bound with addExtern<DAS_BIND_FUNC(%s), SimNode_ExtFuncCallAndCopyOrMove>\n"

" likely cast<> is implemented for the return type, and it should not\n",

fnX->name.c_str(), mod.name.c_str(), fnX->name.c_str());

}

}

fnX->setSideEffects(seFlags);

if (!mod.addFunction(fnX)) {

DAS_FATAL_ERROR("addExtern(%s) failed in module %s\n", fnX->name.c_str(), mod.name.c_str());

}

if ( !expr ) {

DAS_ASSERTF(0,

"its not ok to clone Expression as is."

"if we are here, this means that ::clone function is not written correctly."

"incorrect clone function can be found on the stack above this.");

return nullptr;

}

expr->at = at;

expr->type = type ? make_smart<TypeDecl>(*type) : nullptr;

expr->genFlags = genFlags;

return expr;

if ( expr->type && !expr->type->isAutoOrAlias() && expr->type->isRef() && !expr->type->isRefType() ) {

auto ar2l = make_smart<ExprRef2Value>();

ar2l->subexpr = expr;

ar2l->at = expr->at;

ar2l->type = make_smart<TypeDecl>(*expr->type);

ar2l->type->ref = false;

return ar2l;

} else {

return expr;

}

auto cexpr = clonePtr<ExprReader>(expr);

Expression::clone(cexpr);

cexpr->macro = macro;

cexpr->sequence = sequence;

return cexpr;

auto cexpr = clonePtr<ExprLabel>(expr);

Expression::clone(cexpr);

cexpr->label = label;

cexpr->comment = comment;

return cexpr;

vis.preVisit(this);

if ( subexpr ) {

subexpr = subexpr->visit(vis);

}

return vis.visit(this);

auto cexpr = clonePtr<ExprGoto>(expr);

Expression::clone(cexpr);

cexpr->label = label;

if ( subexpr ) {

cexpr->subexpr = subexpr->clone();

}

return cexpr;

vis.preVisit(this);

subexpr = subexpr->visit(vis);

return vis.visit(this);

auto cexpr = clonePtr<ExprRef2Value>(expr);

Expression::clone(cexpr);

cexpr->subexpr = subexpr->clone();

return cexpr;

vis.preVisit(this);

subexpr = subexpr->visit(vis);

return vis.visit(this);

auto cexpr = clonePtr<ExprRef2Ptr>(expr);

Expression::clone(cexpr);

cexpr->subexpr = subexpr->clone();

return cexpr;

vis.preVisit(this);

subexpr = subexpr->visit(vis);

return vis.visit(this);

auto cexpr = clonePtr<ExprPtr2Ref>(expr);

Expression::clone(cexpr);

cexpr->subexpr = subexpr->clone();

return cexpr;

vis.preVisit(this);

if ( funcType ) {

vis.preVisit(funcType.get());

funcType = funcType->visit(vis);

funcType = vis.visit(funcType.get());

}

return vis.visit(this);

auto cexpr = clonePtr<ExprAddr>(expr);

Expression::clone(cexpr);

cexpr->target = target;

cexpr->func = func;

if (funcType) cexpr->funcType = make_smart<TypeDecl>(*funcType);

return cexpr;