void c_GenVectorWaitHandle::onUnblocked() {
for (; m_iterPos < m_deps->size(); ++m_iterPos) {
Cell* current = tvAssertCell(m_deps->at(m_iterPos));
assert(current->m_type == KindOfObject);
assert(dynamic_cast<c_WaitHandle*>(current->m_data.pobj));
auto child = static_cast<c_WaitHandle*>(current->m_data.pobj);
if (child->isSucceeded()) {
cellSet(child->getResult(), *current);
} else if (child->isFailed()) {
putException(m_exception, child->getException());
} else {
assert(dynamic_cast<c_WaitableWaitHandle*>(child));
auto child_wh = static_cast<c_WaitableWaitHandle*>(child);
try {
blockOn(child_wh);
return;
} catch (const Object& cycle_exception) {
putException(m_exception, cycle_exception.get());
}
}
}
if (m_exception.isNull()) {
setResult(make_tv<KindOfObject>(m_deps.get()));
m_deps = nullptr;
} else {
setException(m_exception.get());
m_exception = nullptr;
m_deps = nullptr;
}
}
Object c_GenMapWaitHandle::ti_create(const Variant& dependencies) {
if (UNLIKELY(!dependencies.isObject() ||
dependencies.getObjectData()->getCollectionType() !=
Collection::MapType)) {
Object e(SystemLib::AllocInvalidArgumentExceptionObject(
"Expected dependencies to be an instance of Map"));
throw e;
}
assert(dependencies.getObjectData()->instanceof(c_Map::classof()));
auto deps = p_Map::attach(c_Map::Clone(dependencies.getObjectData()));
for (ssize_t iter_pos = deps->iter_begin();
deps->iter_valid(iter_pos);
iter_pos = deps->iter_next(iter_pos)) {
auto* current = tvAssertCell(deps->iter_value(iter_pos));
if (UNLIKELY(!c_WaitHandle::fromCell(current))) {
Object e(SystemLib::AllocInvalidArgumentExceptionObject(
"Expected dependencies to be a map of WaitHandle instances"));
throw e;
}
}
Object exception;
for (ssize_t iter_pos = deps->iter_begin();
deps->iter_valid(iter_pos);
iter_pos = deps->iter_next(iter_pos)) {
auto* current = tvAssertCell(deps->iter_value(iter_pos));
assert(current->m_type == KindOfObject);
assert(current->m_data.pobj->instanceof(c_WaitHandle::classof()));
auto child = static_cast<c_WaitHandle*>(current->m_data.pobj);
if (child->isSucceeded()) {
auto k = deps->iter_key(iter_pos);
deps->set(k.asCell(), &child->getResult());
} else if (child->isFailed()) {
putException(exception, child->getException());
} else {
assert(child->instanceof(c_WaitableWaitHandle::classof()));
auto child_wh = static_cast<c_WaitableWaitHandle*>(child);
p_GenMapWaitHandle my_wh = NEWOBJ(c_GenMapWaitHandle)();
my_wh->initialize(exception, deps.get(), iter_pos, child_wh);
AsioSession* session = AsioSession::Get();
if (UNLIKELY(session->hasOnGenMapCreateCallback())) {
session->onGenMapCreate(my_wh.get(), dependencies);
}
return my_wh;
}
}
if (exception.isNull()) {
return Object::attach(c_StaticWaitHandle::CreateSucceeded(
make_tv<KindOfObject>(deps.detach())));
} else {
return Object::attach(c_StaticWaitHandle::CreateFailed(exception.detach()));
}
}
GlxBackend::~GlxBackend()
{
if (isFailed()) {
m_overlayWindow->destroy();
}
// TODO: cleanup in error case
// do cleanup after initBuffer()
cleanupGL();
doneCurrent();
gs_tripleBufferUndetected = true;
gs_tripleBufferNeedsDetection = false;
if (ctx)
glXDestroyContext(display(), ctx);
if (glxWindow)
glXDestroyWindow(display(), glxWindow);
if (window)
XDestroyWindow(display(), window);
overlayWindow()->destroy();
delete m_overlayWindow;
}
float CVX_Material::stress(float strain, float transverseStrainSum, bool forceLinear)
{
//reference: http://www.colorado.edu/engineering/CAS/courses.d/Structures.d/IAST.Lect05.d/IAST.Lect05.pdf page 10
if (isFailed(strain)) return 0.0f; //if a failure point is set and exceeded, we've broken!
if (strain <= strainData[1] || linear || forceLinear){ //for compression/first segment and linear materials (forced or otherwise), simple calculation
if (nu==0.0f) return E*strain;
else return eHat()*((1-nu)*strain + nu*transverseStrainSum);
}
//the non-linear feature with non-zero poissons ratio is currently experimental
int DataCount = modelDataPoints();
for (int i=2; i<DataCount; i++){ //go through each segment in the material model (skipping the first segment because it has already been handled.
if (strain <= strainData[i] || i==DataCount-1){ //if in the segment ending with this point (or if this is the last point extrapolate out
float Perc = (strain-strainData[i-1])/(strainData[i]-strainData[i-1]);
float basicStress = stressData[i-1] + Perc*(stressData[i]-stressData[i-1]);
if (nu==0.0f) return basicStress;
else { //accounting for volumetric effects
float modulus = (stressData[i]-stressData[i-1])/(strainData[i]-strainData[i-1]);
float modulusHat = modulus/((1-2*nu)*(1+nu));
float effectiveStrain = basicStress/modulus; //this is the strain at which a simple linear stress strain line would hit this point at the definied modulus
float effectiveTransverseStrainSum = transverseStrainSum*(effectiveStrain/strain);
return modulusHat*((1-nu)*effectiveStrain + nu*effectiveTransverseStrainSum);
}
}
}
assert(false); //should never reach this point
return 0.0f;
}
Object c_GenArrayWaitHandle::ti_create(const char* cls, CArrRef dependencies) {
Array deps = dependencies->copy();
for (ssize_t iter_pos = deps->iter_begin();
iter_pos != ArrayData::invalid_index;
iter_pos = deps->iter_advance(iter_pos)) {
TypedValue* current = deps->nvGetValueRef(iter_pos);
if (UNLIKELY(current->m_type == KindOfRef)) {
tvUnbox(current);
}
if (!c_WaitHandle::fromTypedValue(current) &&
!IS_NULL_TYPE(current->m_type)) {
Object e(SystemLib::AllocInvalidArgumentExceptionObject(
"Expected dependencies to be an array of WaitHandle instances"));
throw e;
}
}
Object exception;
for (ssize_t iter_pos = deps->iter_begin();
iter_pos != ArrayData::invalid_index;
iter_pos = deps->iter_advance(iter_pos)) {
TypedValue* current = deps->nvGetValueRef(iter_pos);
if (IS_NULL_TYPE(current->m_type)) {
// {uninit,null} yields null
tvWriteNull(current);
continue;
}
assert(current->m_type == KindOfObject);
assert(dynamic_cast<c_WaitHandle*>(current->m_data.pobj));
auto child = static_cast<c_WaitHandle*>(current->m_data.pobj);
if (child->isSucceeded()) {
tvSetIgnoreRef(child->getResult(), current);
} else if (child->isFailed()) {
putException(exception, child->getException());
} else {
assert(dynamic_cast<c_WaitableWaitHandle*>(child));
auto child_wh = static_cast<c_WaitableWaitHandle*>(child);
c_GenArrayWaitHandle* my_wh = NEWOBJ(c_GenArrayWaitHandle)();
my_wh->initialize(exception, deps, iter_pos, child_wh);
return my_wh;
}
}
if (exception.isNull()) {
TypedValue tv;
tv.m_type = KindOfArray;
tv.m_data.parr = deps.get();
return c_StaticResultWaitHandle::Create(&tv);
} else {
return c_StaticExceptionWaitHandle::Create(exception.get());
}
}
//------------------------------------------------------------------------------
// updateData() -- Update the log file
//------------------------------------------------------------------------------
void Logger::updateData(const LCreal dt)
{
BaseClass::updateData(dt);
// Open the log file (if we haven't tried before)
if (!isOpen() && !isFailed()) {
openFile();
}
}
void Map::update (uint32_t deltaTime)
{
_pointCount = 0;
if (_pause)
return;
_timeManager.update(deltaTime);
if (_restartDue > 0 && _restartDue <= _time) {
const std::string currentName = getName();
info(LOG_MAP, "restarting map " + currentName);
if (isFailed()) {
const Map::PlayerList& players = getPlayers();
for (Map::PlayerListConstIter i = players.begin(); i != players.end(); ++i) {
const Player* p = *i;
GameEvent.failedMap(p->getClientId(), currentName, getFailReason(p), getTheme());
}
System.track("mapstate", "failed:" + currentName);
} else {
load(currentName);
}
return;
}
if (_world) {
_time += deltaTime;
while (_time - _physicsTime >= Constant::DELTA_PHYSICS_MILLIS) {
_physicsTime += Constant::DELTA_PHYSICS_MILLIS;
{
ExecutionTime visitTime("VisitTime", 2000L);
visitEntities(this);
}
handleFlyingNPC();
handleFishNPC();
if (_time >= _warmupPhase) {
_entityRemovalAllowed = false;
ExecutionTime stepTime("StepTime", 2000L);
_world->Step(Constant::DELTA_PHYSICS_SECONDS, 8, 3);
_entityRemovalAllowed = true;
}
}
const int t = _referenceTime - _time / 1000;
if (t < 0)
return;
static int lastT = 0;
if (lastT != t) {
GameEvent.sendTimeRemaining(t);
lastT = t;
}
}
}
String c_WaitHandle::t_getname() {
if (isSucceeded()) {
return s_result;
} else if (isFailed()) {
return s_exception;
}
assert(instanceof(c_WaitableWaitHandle::classof()));
return static_cast<c_WaitableWaitHandle*>(this)->getName();
}
Object c_GenVectorWaitHandle::ti_create(const Variant& dependencies) {
if (UNLIKELY(!dependencies.isObject() ||
dependencies.getObjectData()->getCollectionType() !=
Collection::VectorType)) {
Object e(SystemLib::AllocInvalidArgumentExceptionObject(
"Expected dependencies to be an instance of Vector"));
throw e;
}
assert(dependencies.getObjectData()->instanceof(c_Vector::classof()));
auto deps = SmartObject<c_Vector>::attach(
c_Vector::Clone(dependencies.getObjectData()));
for (int64_t iter_pos = 0; iter_pos < deps->size(); ++iter_pos) {
Cell* current = deps->at(iter_pos);
if (UNLIKELY(!c_WaitHandle::fromCell(current))) {
Object e(SystemLib::AllocInvalidArgumentExceptionObject(
"Expected dependencies to be a vector of WaitHandle instances"));
throw e;
}
}
Object exception;
for (int64_t iter_pos = 0; iter_pos < deps->size(); ++iter_pos) {
auto current = tvAssertCell(deps->at(iter_pos));
assert(current->m_type == KindOfObject);
assert(current->m_data.pobj->instanceof(c_WaitHandle::classof()));
auto child = static_cast<c_WaitHandle*>(current->m_data.pobj);
if (child->isSucceeded()) {
auto result = child->getResult();
deps->set(iter_pos, &result);
} else if (child->isFailed()) {
putException(exception, child->getException());
} else {
assert(child->instanceof(c_WaitableWaitHandle::classof()));
auto child_wh = static_cast<c_WaitableWaitHandle*>(child);
SmartObject<c_GenVectorWaitHandle> my_wh(newobj<c_GenVectorWaitHandle>());
my_wh->initialize(exception, deps.get(), iter_pos, child_wh);
AsioSession* session = AsioSession::Get();
if (UNLIKELY(session->hasOnGenVectorCreateCallback())) {
session->onGenVectorCreate(my_wh.get(), dependencies);
}
return my_wh;
}
}
if (exception.isNull()) {
return Object::attach(c_StaticWaitHandle::CreateSucceeded(
make_tv<KindOfObject>(deps.detach())));
} else {
return Object::attach(c_StaticWaitHandle::CreateFailed(exception.detach()));
}
}
float CVX_Material::modulus(float strain)
{
if (isFailed(strain)) return 0.0f; //if a failure point is set and exceeded, we've broken!
if (strain <= strainData[1] || linear) return E; //for compression/first segment and linear materials, simple calculation
int DataCount = modelDataPoints();
for (int i=2; i<DataCount; i++){ //go through each segment in the material model (skipping the first segment because it has already been handled.
if (strain <= strainData[i] || i==DataCount-1) return (stressData[i]-stressData[i-1])/(strainData[i]-strainData[i-1]); //if in the segment ending with this point
}
assert(false); //we should never reach this point in the function
return 0.0f;
}
bool Map::isDone () const
{
if (_forcedFinish)
return true;
if (isFailed())
return false;
for (StateMapConstIter i = _state.begin(); i != _state.end(); ++i) {
// if there is an empty target left, we are not yet done
if (i->second == Sokoban::TARGET || i->second == Sokoban::PLAYERONTARGET)
return false;
}
return true;
}
Object c_GenVectorWaitHandle::ti_create(CVarRef dependencies) {
if (UNLIKELY(!dependencies.instanceof(c_Vector::s_cls))) {
Object e(SystemLib::AllocInvalidArgumentExceptionObject(
"Expected dependencies to be an instance of Vector"));
throw e;
}
assert(dynamic_cast<c_Vector*>(dependencies.getObjectData()));
p_Vector deps = static_cast<c_Vector*>(dependencies.getObjectData())->clone();
for (int64_t iter_pos = 0; iter_pos < deps->size(); ++iter_pos) {
Cell* current = deps->at(iter_pos);
if (UNLIKELY(!c_WaitHandle::fromCell(current))) {
Object e(SystemLib::AllocInvalidArgumentExceptionObject(
"Expected dependencies to be a vector of WaitHandle instances"));
throw e;
}
}
Object exception;
for (int64_t iter_pos = 0; iter_pos < deps->size(); ++iter_pos) {
Cell* current = tvAssertCell(deps->at(iter_pos));
assert(current->m_type == KindOfObject);
assert(dynamic_cast<c_WaitHandle*>(current->m_data.pobj));
auto child = static_cast<c_WaitHandle*>(current->m_data.pobj);
if (child->isSucceeded()) {
cellSet(child->getResult(), *current);
} else if (child->isFailed()) {
putException(exception, child->getException());
} else {
assert(dynamic_cast<c_WaitableWaitHandle*>(child));
auto child_wh = static_cast<c_WaitableWaitHandle*>(child);
p_GenVectorWaitHandle my_wh = NEWOBJ(c_GenVectorWaitHandle)();
my_wh->initialize(exception, deps.get(), iter_pos, child_wh);
AsioSession* session = AsioSession::Get();
if (UNLIKELY(session->hasOnGenVectorCreateCallback())) {
session->onGenVectorCreate(my_wh.get(), dependencies);
}
return my_wh;
}
}
if (exception.isNull()) {
return c_StaticResultWaitHandle::Create(make_tv<KindOfObject>(deps.get()));
} else {
return c_StaticExceptionWaitHandle::Create(exception.get());
}
}
Object c_SetResultToRefWaitHandle::ti_create(CObjRef wait_handle, VRefParam ref) {
TypedValue* var_or_cell = ref->asTypedValue();
if (wait_handle.isNull()) {
tvSetNull(*var_or_cell);
return wait_handle;
}
if (!wait_handle.get()->getAttribute(ObjectData::IsWaitHandle)) {
Object e(SystemLib::AllocInvalidArgumentExceptionObject(
"Expected wait_handle to be an instance of WaitHandle or null"));
throw e;
}
auto wh = static_cast<c_WaitHandle*>(wait_handle.get());
// succeeded? set result to ref and give back succeeded wait handle
if (wh->isSucceeded()) {
tvSet(wh->getResult(), *var_or_cell);
return wh;
}
// failed? reset ref and give back failed wait handle
if (wh->isFailed()) {
tvSetNull(*var_or_cell);
return wh;
}
// it's still running so it must be WaitableWaitHandle
auto child = static_cast<c_WaitableWaitHandle*>(wh);
// import child into the current context, detect cross-context cycles
auto session = AsioSession::Get();
if (session->isInContext()) {
child->enterContext(session->getCurrentContextIdx());
}
// make sure the reference is properly boxed so that we can store cell pointer
if (UNLIKELY(var_or_cell->m_type != KindOfRef)) {
tvBox(var_or_cell);
}
p_SetResultToRefWaitHandle my_wh = NEWOBJ(c_SetResultToRefWaitHandle)();
my_wh->initialize(child, var_or_cell->m_data.pref);
if (UNLIKELY(session->hasOnSetResultToRefCreateCallback())) {
session->onSetResultToRefCreate(my_wh.get(), child);
}
return my_wh;
}
void c_GenMapWaitHandle::onUnblocked() {
assert(getState() == STATE_BLOCKED);
for (;
m_deps->iter_valid(m_iterPos);
m_iterPos = m_deps->iter_next(m_iterPos)) {
auto* current = tvAssertCell(m_deps->iter_value(m_iterPos));
assert(current->m_type == KindOfObject);
assert(current->m_data.pobj->instanceof(c_WaitHandle::classof()));
auto child = static_cast<c_WaitHandle*>(current->m_data.pobj);
if (child->isSucceeded()) {
auto k = m_deps->iter_key(m_iterPos);
m_deps->set(k.asCell(), &child->getResult());
} else if (child->isFailed()) {
putException(m_exception, child->getException());
} else {
assert(child->instanceof(c_WaitHandle::classof()));
auto child_wh = static_cast<c_WaitableWaitHandle*>(child);
try {
if (isInContext()) {
child_wh->enterContext(getContextIdx());
}
detectCycle(child_wh);
blockOn(child_wh);
return;
} catch (const Object& cycle_exception) {
putException(m_exception, cycle_exception.get());
}
}
}
auto const parentChain = getFirstParent();
if (m_exception.isNull()) {
setState(STATE_SUCCEEDED);
tvWriteObject(m_deps.get(), &m_resultOrException);
} else {
setState(STATE_FAILED);
tvWriteObject(m_exception.get(), &m_resultOrException);
m_exception = nullptr;
}
m_deps = nullptr;
UnblockChain(parentChain);
decRefObj(this);
}
EglOnXBackend::~EglOnXBackend()
{
if (isFailed()) {
m_overlayWindow->destroy();
}
cleanupGL();
checkGLError("Cleanup");
doneCurrent();
eglDestroyContext(dpy, ctx);
eglDestroySurface(dpy, surface);
eglTerminate(dpy);
eglReleaseThread();
if (overlayWindow()->window()) {
overlayWindow()->destroy();
}
delete m_overlayWindow;
}
void c_GenArrayWaitHandle::onUnblocked() {
for (;
m_iterPos != ArrayData::invalid_index;
m_iterPos = m_deps->iter_advance(m_iterPos)) {
TypedValue* current = m_deps->nvGetValueRef(m_iterPos);
if (IS_NULL_TYPE(current->m_type)) {
// {uninit,null} yields null
tvWriteNull(current);
continue;
}
assert(current->m_type == KindOfObject);
assert(dynamic_cast<c_WaitHandle*>(current->m_data.pobj));
auto child = static_cast<c_WaitHandle*>(current->m_data.pobj);
if (child->isSucceeded()) {
tvSetIgnoreRef(child->getResult(), current);
} else if (child->isFailed()) {
putException(m_exception, child->getException());
} else {
assert(dynamic_cast<c_WaitableWaitHandle*>(child));
auto child_wh = static_cast<c_WaitableWaitHandle*>(child);
try {
blockOn(child_wh);
return;
} catch (const Object& cycle_exception) {
putException(m_exception, cycle_exception.get());
}
}
}
if (m_exception.isNull()) {
TypedValue result;
result.m_type = KindOfArray;
result.m_data.parr = m_deps.get();
setResult(&result);
m_deps = nullptr;
} else {
setException(m_exception.get());
m_exception = nullptr;
m_deps = nullptr;
}
}
void c_GenVectorWaitHandle::onUnblocked() {
assert(getState() == STATE_BLOCKED);
for (; m_iterPos < m_deps->size(); ++m_iterPos) {
Cell* current = tvAssertCell(m_deps->at(m_iterPos));
assert(current->m_type == KindOfObject);
assert(current->m_data.pobj->instanceof(c_WaitHandle::classof()));
auto child = static_cast<c_WaitHandle*>(current->m_data.pobj);
if (child->isSucceeded()) {
auto result = child->getResult();
m_deps->set(m_iterPos, &result);
} else if (child->isFailed()) {
putException(m_exception, child->getException());
} else {
assert(child->instanceof(c_WaitableWaitHandle::classof()));
auto child_wh = static_cast<c_WaitableWaitHandle*>(child);
try {
detectCycle(child_wh);
child_wh->getParentChain()
.addParent(m_blockable, AsioBlockable::Kind::GenVectorWaitHandle);
return;
} catch (const Object& cycle_exception) {
putException(m_exception, cycle_exception.get());
}
}
}
auto parentChain = getParentChain();
if (m_exception.isNull()) {
setState(STATE_SUCCEEDED);
tvWriteObject(m_deps.get(), &m_resultOrException);
} else {
setState(STATE_FAILED);
tvWriteObject(m_exception.get(), &m_resultOrException);
m_exception = nullptr;
}
m_deps = nullptr;
parentChain.unblock();
decRefObj(this);
}
int main( int argc, char* argv[] ) {
std::cout << "Tegan Language Compiler v.0.1"
<< std::endl<< std::endl << std::endl;
FILE* file = fopen( argv[ 1 ], "r" );
if ( file == 0 ) {
std::cout << "Can't open file " << argv[ 1 ] << "\n";
return 1;
}
if ( argv[ 2 ] == NULL ) {
std::cout << "Specify output file" << std::endl;
return 1;
}
char* output = argv[ 2 ];
auto parser = Parser();
Node* root = parser.parse( file );
std::cout << std::endl;
Printer printer = Printer();
Codegen codegen = Codegen();
for ( int i = 3; i < argc; ++i ) {
addOpt( argv[ i ], codegen );
}
if ( root != NULL ) {
std::cout << std::endl;
root->accept( printer );
if ( !parser.isFailed() ) {
std::cout << std::endl;
root->accept( codegen );
codegen.dump();
codegen.save( output );
}
} else {
std::cout << "EXIT" << std::endl;
}
std::cout << std::endl << std::endl << std::endl;
}
void c_GenVectorWaitHandle::onUnblocked() {
assert(getState() == STATE_BLOCKED);
for (; m_iterPos < m_deps->size(); ++m_iterPos) {
Cell* current = tvAssertCell(m_deps->at(m_iterPos));
assert(current->m_type == KindOfObject);
assert(current->m_data.pobj->instanceof(c_WaitHandle::classof()));
auto child = static_cast<c_WaitHandle*>(current->m_data.pobj);
if (child->isSucceeded()) {
cellSet(child->getResult(), *current);
} else if (child->isFailed()) {
putException(m_exception, child->getException());
} else {
assert(child->instanceof(c_WaitableWaitHandle::classof()));
auto child_wh = static_cast<c_WaitableWaitHandle*>(child);
try {
if (isInContext()) {
child_wh->enterContext(getContextIdx());
}
detectCycle(child_wh);
blockOn(child_wh);
return;
} catch (const Object& cycle_exception) {
putException(m_exception, cycle_exception.get());
}
}
}
if (m_exception.isNull()) {
setState(STATE_SUCCEEDED);
tvWriteObject(m_deps.get(), &m_resultOrException);
} else {
setState(STATE_FAILED);
tvWriteObject(m_exception.get(), &m_resultOrException);
m_exception = nullptr;
}
m_deps = nullptr;
done();
}
//------------------------------------------------------------------------------
// print to output stream
//------------------------------------------------------------------------------
void PrintHandler::printToOutput(const char* const msg)
{
// First pass? Do we need to open a file?
if (firstPassFlg) {
if ( filename != 0 && !isOpen() && !isFailed() ) {
openFile();
}
firstPassFlg = false;
}
// Output to a file?
if (sout != 0 && isOpen()) {
*sout << msg << std::endl;
fileEmpty = false;
}
// Or to the standard output stream
else {
std::cout << msg << std::endl;
}
}
void c_GenMapWaitHandle::onUnblocked() {
for (;
m_deps->iter_valid(m_iterPos);
m_iterPos = m_deps->iter_next(m_iterPos)) {
Cell* current = tvAssertCell(m_deps->iter_value(m_iterPos));
assert(current->m_type == KindOfObject);
assert(current->m_data.pobj->instanceof(c_WaitHandle::classof()));
auto child = static_cast<c_WaitHandle*>(current->m_data.pobj);
if (child->isSucceeded()) {
cellSet(child->getResult(), *current);
} else if (child->isFailed()) {
putException(m_exception, child->getException());
} else {
assert(child->instanceof(c_WaitHandle::classof()));
auto child_wh = static_cast<c_WaitableWaitHandle*>(child);
try {
if (isInContext()) {
child_wh->enterContext(getContextIdx());
}
detectCycle(child_wh);
blockOn(child_wh);
return;
} catch (const Object& cycle_exception) {
putException(m_exception, cycle_exception.get());
}
}
}
if (m_exception.isNull()) {
setResult(make_tv<KindOfObject>(m_deps.get()));
m_deps = nullptr;
} else {
setException(m_exception.get());
m_exception = nullptr;
m_deps = nullptr;
}
}
GlxBackend::~GlxBackend()
{
if (isFailed()) {
m_overlayWindow->destroy();
}
// TODO: cleanup in error case
// do cleanup after initBuffer()
cleanupGL();
checkGLError("Cleanup");
doneCurrent();
if (ctx)
glXDestroyContext(display(), ctx);
if (glxWindow)
glXDestroyWindow(display(), glxWindow);
if (window)
XDestroyWindow(display(), window);
overlayWindow()->destroy();
delete m_overlayWindow;
}
bool c_WaitHandle::t_isfailed() {
return isFailed();
}
Object c_WaitHandle::t_getexceptioniffailed() {
return isFailed() ? getException() : nullptr;
}
Object c_GenMapWaitHandle::ti_create(const Variant& dependencies) {
ObjectData* obj;
if (UNLIKELY(!dependencies.isObject() ||
!(obj = dependencies.getObjectData())->isCollection() ||
obj->collectionType() != CollectionType::Map)) {
SystemLib::throwInvalidArgumentExceptionObject(
"Expected dependencies to be an instance of Map");
}
assertx(obj->collectionType() == CollectionType::Map);
auto deps = req::ptr<c_Map>::attach(c_Map::Clone(obj));
auto ctx_idx = std::numeric_limits<context_idx_t>::max();
for (ssize_t iter_pos = deps->iter_begin();
deps->iter_valid(iter_pos);
iter_pos = deps->iter_next(iter_pos)) {
auto* current = tvAssertCell(deps->iter_value(iter_pos));
auto const child = c_WaitHandle::fromCell(current);
if (UNLIKELY(!child)) {
SystemLib::throwInvalidArgumentExceptionObject(
"Expected dependencies to be a map of WaitHandle instances");
}
if (!child->isFinished()) {
ctx_idx = std::min(
ctx_idx,
static_cast<c_WaitableWaitHandle*>(child)->getContextIdx()
);
}
}
Object exception;
for (ssize_t iter_pos = deps->iter_begin();
deps->iter_valid(iter_pos);
iter_pos = deps->iter_next(iter_pos)) {
auto* current = tvAssertCell(deps->iter_value(iter_pos));
assert(current->m_type == KindOfObject);
assert(current->m_data.pobj->instanceof(c_WaitHandle::classof()));
auto child = static_cast<c_WaitHandle*>(current->m_data.pobj);
if (child->isSucceeded()) {
auto k = deps->iter_key(iter_pos);
auto result = child->getResult();
deps->set(k.asCell(), &result);
} else if (child->isFailed()) {
putException(exception, child->getException());
} else {
assert(child->instanceof(c_WaitableWaitHandle::classof()));
auto child_wh = static_cast<c_WaitableWaitHandle*>(child);
auto my_wh = req::make<c_GenMapWaitHandle>();
my_wh->initialize(exception, deps.get(), iter_pos, ctx_idx, child_wh);
AsioSession* session = AsioSession::Get();
if (UNLIKELY(session->hasOnGenMapCreate())) {
session->onGenMapCreate(my_wh.get(), dependencies);
}
return Object(std::move(my_wh));
}
}
if (exception.isNull()) {
return Object::attach(c_StaticWaitHandle::CreateSucceeded(
make_tv<KindOfObject>(deps.detach())));
} else {
return Object::attach(c_StaticWaitHandle::CreateFailed(exception.detach()));
}
}
//------------------------------------------------------------------------------
// Read a record
//------------------------------------------------------------------------------
const DataRecordHandle* FileReader::readRecordImp()
{
DataRecordHandle* handle = nullptr;
// First pass? Does the file need to be opened?
if (firstPassFlg) {
if ( !isOpen() && !isFailed() ) {
openFile();
}
firstPassFlg = false;
}
// When the file is open and ready ...
if ( isOpen() && !isFailed() && !sin->eof() ) {
// Number of bytes in the next serialized DataRecord
unsigned int n = 0;
// ---
// Read the size of the next serialized DataRecord
// ---
char nbuff[8];
sin->read(nbuff, 4);
// Check for error or eof
if ( sin->eof() || sin->fail() ) {
fileFailed = sin->fail();
if (fileFailed && isMessageEnabled(MSG_ERROR | MSG_WARNING)) {
std::cerr << "FileReader::readRecord() -- error reading data record size" << std::endl;
}
}
// Ok then get the size of the message from the buffer
else {
nbuff[4] = '\0';
n = std::atoi(nbuff);
}
// ---
// Read the serialized DataRecord from the file, parse it as a DataRecord
// and put it into a Handle.
// ---
if (n > 0) {
// Read message into ibuf
sin->read(ibuf, n);
// Check for error or eof
if ( sin->eof() || sin->fail() ) {
if (isMessageEnabled(MSG_ERROR | MSG_WARNING)) {
std::cerr << "FileReader::readRecord() -- error reading data record" << std::endl;
}
fileFailed = true;
}
// Ok, create the DataRecord with handle
else {
// Parse the DataRecord
std::string wireFormat(ibuf, n);
Pb::DataRecord* dataRecord = new Pb::DataRecord();
bool ok = dataRecord->ParseFromString(wireFormat);
// Create a handle for the DataRecord (it now has ownership)
if (ok) {
handle = new DataRecordHandle(dataRecord);
}
// parsing error
else if (isMessageEnabled(MSG_ERROR | MSG_WARNING)) {
std::cerr << "FileReader::readRecord() -- ParseFromString() error" << std::endl;
delete dataRecord;
dataRecord = nullptr;
}
}
}
}
return handle;
}
