Variant f_exit(CVarRef status /* = null_variant */) {
if (status.isString()) {
echo(status.toString());
throw ExitException(0);
}
throw ExitException(status.toInt32());
}
void Sys::Error(Str::StringRef message)
{
// Only try sending an ErrorMsg once
static std::atomic_flag errorEntered;
if (!errorEntered.test_and_set()) {
// Disable checks for sending sync messages when handling async messages.
// At this point we don't really care since this is an error.
VM::rootChannel.canSendSyncMsg = true;
// Try to tell the engine about the error, but ignore errors doing so.
try {
VM::SendMsg<VM::ErrorMsg>(message);
} catch (...) {}
}
#ifdef BUILD_VM_IN_PROCESS
// Then engine will close the root socket when it wants us to exit, which
// will trigger an error in the IPC functions. If we reached this point then
// we try to exit the thread semi-cleanly by throwing an exception.
throw ExitException();
#else
// The SendMsg should never return since the engine should kill our process.
// Just in case it doesn't, exit here.
_exit(255);
#endif
}
void Coroutine::swap() {
// Swaps control to this coroutine, causing the current coroutine to suspend.
// This function returns when another coroutine swaps back to this coroutine.
// If a coroutine dies it is asleep, then it throws an ExitException, which
// will cause the coroutine to exit.
Coroutine* current = coroCurrent;
switch (status_) {
case Coroutine::DELETED: break;
case Coroutine::RUNNABLE: status_ = Coroutine::RUNNING; break;
case Coroutine::NEW: status_ = Coroutine::RUNNING; break;
case Coroutine::BLOCKED: status_ = Coroutine::RUNNING; break;
case Coroutine::RUNNING: return; // already running
case Coroutine::EXITED: assert(!"coroutine is dead"); break;
default: assert(!"illegal state"); break;
}
coroCurrent = this;
coroSwapContext(current, this);
switch (coroCurrent->status_) {
case Coroutine::DELETED: if (!coroCurrent->isMain()) { throw ExitException(); } break;
case Coroutine::RUNNING: break;
case Coroutine::RUNNABLE: // fallthrough
case Coroutine::BLOCKED: // fallthrough
case Coroutine::NEW: // fallthrough
case Coroutine::EXITED: // fallthrough
default: assert(!"illegal state"); break;
}
}
bool ExitIterator::nextImpl(store::Item_t& result, PlanState& planState) const
{
PlanIteratorState* state;
DEFAULT_STACK_INIT(PlanIteratorState, state, planState);
throw ExitException(new PlanIteratorWrapper(theChild, planState));
STACK_END(state);
}
static Variant HHVM_FUNCTION(assert, const Variant& assertion,
const Variant& message /* = null */) {
if (!s_option_data->assertActive) return true;
CallerFrame cf;
Offset callerOffset;
auto const fp = cf(&callerOffset);
auto const passed = [&]() -> bool {
if (assertion.isString()) {
if (RuntimeOption::EvalAuthoritativeMode) {
// We could support this with compile-time string literals,
// but it's not yet implemented.
throw_not_supported("assert()",
"assert with strings argument in RepoAuthoritative mode");
}
return eval_for_assert(fp, assertion.toString()).toBoolean();
}
return assertion.toBoolean();
}();
if (passed) return true;
if (!s_option_data->assertCallback.isNull()) {
auto const unit = fp->m_func->unit();
PackedArrayInit ai(3);
ai.append(String(const_cast<StringData*>(unit->filepath())));
ai.append(Variant(unit->getLineNumber(callerOffset)));
ai.append(assertion.isString() ? assertion : empty_string_variant_ref);
HHVM_FN(call_user_func)(s_option_data->assertCallback, ai.toArray());
}
if (s_option_data->assertException) {
if (message.isObject()) {
Object exn = message.toObject();
if (exn.instanceof(SystemLib::s_AssertionErrorClass)) {
throw_object(exn);
}
}
SystemLib::throwExceptionObject(message.toString());
}
if (s_option_data->assertWarning) {
String name(message.isNull() ? "Assertion" : message.toString());
auto const str = !assertion.isString()
? " failed"
: concat3(" \"", assertion.toString(), "\" failed");
raise_warning("assert(): %s%s", name.data(), str.data());
}
if (s_option_data->assertBail) {
throw ExitException(1);
}
return init_null();
}
bool
Exit::operator()(std::pair<IOperand *, IOperand *> &, bool const)
{
throw ExitException();
return ("Dymethy" && "Lamine");
}
void ExitCommand::execute(long time)
{
throw ExitException();
}
boost::uint32_t Player::getControllerState(const Uint8 *keyboardState) const throw (ExitException)
{
boost::uint32_t state(0);
if (kmap)
{
if (keyboardState[kmap->getSDLKey(KEY_L)] == SDL_PRESSED) state |= SNES_TL_MASK;
if (keyboardState[kmap->getSDLKey(KEY_R)] == SDL_PRESSED) state |= SNES_TR_MASK;
if (keyboardState[kmap->getSDLKey(KEY_X)] == SDL_PRESSED) state |= SNES_X_MASK;
if (keyboardState[kmap->getSDLKey(KEY_Y)] == SDL_PRESSED) state |= SNES_Y_MASK;
if (keyboardState[kmap->getSDLKey(KEY_B)] == SDL_PRESSED) state |= SNES_B_MASK;
if (keyboardState[kmap->getSDLKey(KEY_A)] == SDL_PRESSED) state |= SNES_A_MASK;
if (keyboardState[kmap->getSDLKey(KEY_START)] == SDL_PRESSED) state |= SNES_START_MASK;
if (keyboardState[kmap->getSDLKey(KEY_SELECT)] == SDL_PRESSED) state |= SNES_SELECT_MASK;
if (keyboardState[kmap->getSDLKey(KEY_UP)] == SDL_PRESSED) state |= SNES_UP_MASK;
if (keyboardState[kmap->getSDLKey(KEY_DOWN)] == SDL_PRESSED) state |= SNES_DOWN_MASK;
if (keyboardState[kmap->getSDLKey(KEY_LEFT)] == SDL_PRESSED) state |= SNES_LEFT_MASK;
if (keyboardState[kmap->getSDLKey(KEY_RIGHT)] == SDL_PRESSED) state |= SNES_RIGHT_MASK;
}
else
{
PluggedJoystick &j = *joystick;
static bool turbo(false);
static int OldSkipFrame(0);
if (j[JB_L]) state |= SNES_TL_MASK;
if (j[JB_R]) state |= SNES_TR_MASK;
if (j[JB_X]) state |= SNES_X_MASK;
if (j[JB_Y]) state |= SNES_Y_MASK;
if (j[JB_B]) state |= SNES_B_MASK;
if (j[JB_A]) state |= SNES_A_MASK;
if (j[JB_START]) state |= SNES_START_MASK;
if (j[JB_SELECT]) state |= SNES_SELECT_MASK;
if (j[JA_LR] == LEFT) state |= SNES_LEFT_MASK;
if (j[JA_LR] == RIGHT) state |= SNES_RIGHT_MASK;
if (j[JA_UD] == UP) state |= SNES_UP_MASK;
if (j[JA_UD] == DOWN) state |= SNES_DOWN_MASK;
if (j[JB_QUIT])
throw ExitException();
if (!j[JB_ACCEL])
{
if (turbo)
{
turbo = false;
Settings.SkipFrames = OldSkipFrame;
}
}
else
{
if (!turbo)
{
turbo = true;
OldSkipFrame = Settings.SkipFrames;
Settings.SkipFrames = 10;
}
}
}
return state;
}