bool ExecutionContext::obFlush() {
ASSERT(m_protectedLevel >= 0);
if ((int)m_buffers.size() > m_protectedLevel) {
list<OutputBuffer*>::const_iterator iter = m_buffers.end();
OutputBuffer *last = *(--iter);
if (iter != m_buffers.begin()) {
OutputBuffer *prev = *(--iter);
if (last->handler.isNull()) {
prev->oss << last->oss.str();
} else {
try {
string output = last->oss.str();
String sout(output.data(), output.length(), AttachLiteral);
Variant tout =
f_call_user_func_array(last->handler, CREATE_VECTOR1(sout));
sout = tout.toString();
prev->oss << string(sout.data(), sout.size());
} catch (...) {
prev->oss << last->oss.str();
}
}
last->oss.str("");
return true;
}
cout << last->oss.str();
last->oss.str("");
}
return false;
}
bool BaseExecutionContext::onUnhandledException(Object e) {
String err = e.toString();
if (RuntimeOption::AlwaysLogUnhandledExceptions) {
Logger::Error("HipHop Fatal error: Uncaught %s", err.data());
}
if (e.instanceof("Exception")) {
// user thrown exception
if (!m_userExceptionHandlers.empty()) {
if (!same(f_call_user_func_array
(m_userExceptionHandlers.back(),
CREATE_VECTOR1(e)),
false)) {
return true;
}
}
} else {
ASSERT(false);
}
m_lastError = err;
if (!RuntimeOption::AlwaysLogUnhandledExceptions) {
Logger::Error("HipHop Fatal error: Uncaught %s", err.data());
}
return false;
}
void EventHook::RunUserProfiler(const ActRec* ar, int mode) {
// Don't do anything if we are running the profiling function itself
// or if we haven't set up a profiler.
if (g_vmContext->m_executingSetprofileCallback ||
g_vmContext->m_setprofileCallback.isNull()) {
return;
}
Transl::VMRegAnchor _;
ExecutingSetprofileCallbackGuard guard;
Array params;
Array frameinfo;
if (mode == ProfileEnter) {
params.append(s_enter);
frameinfo.set(s_args, hhvm_get_frame_args(ar));
} else {
params.append(s_exit);
if (!g_vmContext->m_faults.empty()) {
Fault fault = g_vmContext->m_faults.back();
if (fault.m_faultType == Fault::UserException) {
frameinfo.set(s_exception, fault.m_userException);
}
} else if (!ar->m_func->isBuiltin() &&
!ar->m_func->isGenerator()) {
// TODO (#1131400) This is wrong for builtins
frameinfo.set(s_return, tvAsCVarRef(g_vmContext->m_stack.topTV()));
}
}
params.append(VarNR(ar->m_func->fullName()));
params.append(frameinfo);
f_call_user_func_array(g_vmContext->m_setprofileCallback, params);
}
static void sqlite3_do_callback(sqlite3_context *context, CVarRef callback,
int argc, sqlite3_value **argv, bool is_agg) {
Array params = Array::Create();
php_sqlite3_agg_context *agg_context = NULL;
if (is_agg) {
agg_context = (php_sqlite3_agg_context *)sqlite3_aggregate_context
(context, sizeof(php_sqlite3_agg_context));
params.append(ref(agg_context->context));
params.append(agg_context->row_count);
}
for (int i = 0; i < argc; i++) {
params.append(get_value(argv[i]));
}
Variant ret = f_call_user_func_array(callback, params);
if (!is_agg || !argv) {
/* only set the sqlite return value if we are a scalar function,
* or if we are finalizing an aggregate */
if (ret.isInteger()) {
sqlite3_result_int(context, ret.toInt64());
} else if (ret.isNull()) {
sqlite3_result_null(context);
} else if (ret.isDouble()) {
sqlite3_result_double(context, ret.toDouble());
} else {
String sret = ret.toString();
sqlite3_result_text(context, sret.data(), sret.size(), SQLITE_TRANSIENT);
}
} else {
/* we're stepping in an aggregate; the return value goes into
* the context */
agg_context->context = ret;
}
}
// The default operator called from parallel_for
void operator() (const tbb::blocked_range<int64> &range) const {
callerContext.EnteringOperator();
// Build arguments array
Array args = Array::Create();
// Pass the range start and end as parameters
args.append(range.begin());
args.append(range.end());
// If an input array is defined, copy it and pass as a parameter
if(inputArrayOfVariant.size() > 0) {
Array inputPHPArray = Array::Create();
for(size_t ai=0; ai<inputArrayOfVariant.size(); ai++)
inputPHPArray.append(inputArrayOfVariant[ai]);
Variant inputArrayArg(inputPHPArray.getArrayData());
args.append(inputArrayArg);
}
// Call user supplied callback with arguments
// This is a PHP function of the form worker($begin, $end, $array), returning an array or nothing
// If an array is returned, it is expected to have elements which will be comingled into the output
// array in the elements defined by the input range.
Variant vres = f_call_user_func_array(this->callback, args);
callerContext.ExitingOperator(); // Call this straight after the callback completes
// Return if no result to pass back
if(vres.isNull() || !vres.isArray())
return;
// Now we take the output array [0..N) and assign it into the overall output array at [begin..begin+N)
// Extract output array from result variant
const Array aOutputArray = vres.asCArrRef();
ArrayData *pdOutputArray = aOutputArray.getArrayData();
Variant v = pdOutputArray->reset();
// Check the output array is the same size or smaller than the range passed
size_t outIdx = range.begin();
if(pdOutputArray->size() > (range.end()-range.begin())) {
raise_warning("Callback function returned array larger than passed range size");
return;
}
// Copy each row
while(!v.isBoolean() || v.toBoolean())
{
// printf(" outIdx=%d, v=%s\n", (int)outIdx, v.toString().c_str());
( *pOutputArrayOfVariant ) [outIdx++] = v;
v = pdOutputArray->next();
}
}
String f_call_user_func_serialized(CStrRef input) {
Variant out;
try {
Variant in = f_unserialize(input);
out.set("ret", f_call_user_func_array(in["func"], in["args"]));
} catch (Object &e) {
out.set("exception", e);
}
return f_serialize(out);
}
bool BaseExecutionContext::obFlush() {
ASSERT(m_protectedLevel >= 0);
if ((int)m_buffers.size() > m_protectedLevel) {
std::list<OutputBuffer*>::const_iterator iter = m_buffers.end();
OutputBuffer *last = *(--iter);
const int flag = PHP_OUTPUT_HANDLER_START | PHP_OUTPUT_HANDLER_END;
if (iter != m_buffers.begin()) {
OutputBuffer *prev = *(--iter);
if (last->handler.isNull()) {
prev->oss.absorb(last->oss);
} else {
try {
Variant tout =
f_call_user_func_array(last->handler,
CREATE_VECTOR2(last->oss.detach(), flag));
prev->oss.append(tout.toString());
last->oss.reset();
} catch (...) {
prev->oss.absorb(last->oss);
}
}
return true;
}
if (!last->handler.isNull()) {
try {
Variant tout =
f_call_user_func_array(last->handler,
CREATE_VECTOR2(last->oss.detach(), flag));
String sout = tout.toString();
writeStdout(sout.data(), sout.size());
last->oss.reset();
return true;
} catch (...) {}
}
writeStdout(last->oss.data(), last->oss.size());
last->oss.reset();
return true;
}
return false;
}
bool f_pcntl_signal_dispatch() {
int *signaled = s_signal_handlers->signaled;
for (int i = 0; i < _NSIG; i++) {
if (signaled[i]) {
signaled[i] = 0;
if (s_signal_handlers->handlers.exists(i)) {
f_call_user_func_array(s_signal_handlers->handlers[i],
CREATE_VECTOR1(i));
}
}
}
return true;
}
Variant f_forward_static_call(int _argc, CVarRef function, CArrRef _argv /* = null_array */) {
#ifdef ENABLE_LATE_STATIC_BINDING
CStrRef cls = FrameInjection::GetClassName();
if (cls.empty()) {
raise_error("Cannot call forward_static_call() "
"when no class scope is active");
return null;
}
FrameInjection::StaticClassNameHelper h(ThreadInfo::s_threadInfo.get(), cls);
return f_call_user_func_array(function, _argv, true);
#else
throw NotSupportedException(__func__, "ENABLE_LATE_STATIC_BINDING is off");
#endif
}
Variant do_callback(CVarRef cb, CArrRef args) {
ASSERT(!m_exception);
try {
return f_call_user_func_array(cb, args);
} catch (Object &e) {
ObjectData *od = e.get();
od->incRefCount();
m_exception = od;
m_phpException = true;
} catch (Exception &e) {
m_exception = e.clone();
m_phpException = false;
}
return null;
}
Variant f_iterator_apply(CVarRef obj, CVarRef func,
CArrRef params /* = null_array */) {
if (!obj.instanceof("Traversable")) {
return false;
}
Object pobj = obj.toObject();
pobj->o_invoke("rewind", null_array, -1);
int64 count = 0;
while (same(pobj->o_invoke("valid", null_array, -1), true)) {
if (!same(f_call_user_func_array(func, params), true)) {
break;
}
++count;
pobj->o_invoke("next", null_array, -1);
}
return count;
}
bool ExecutionContext::callUserErrorHandler(const Exception &e, int64 errnum,
bool swallowExceptions) {
int errline = 0;
String errfile;
Array backtrace;
const ExtendedException *ee = dynamic_cast<const ExtendedException*>(&e);
if (ee) {
ArrayPtr arr = ee->getBackTrace();
if (arr) {
backtrace = *arr;
Array top = backtrace.rvalAt(0);
if (!top.isNull()) {
errfile = top.rvalAt("file");
errline = top.rvalAt("line").toInt64();
}
}
}
if (backtrace.isNull()) {
backtrace = stackTraceToBackTrace(e.getStackTrace());
}
bool retval = false;
RequestData::Data *data = s_request_data->data;
if (!data->systemExceptionHandlers.empty()) {
// Avoid calling the user error handler recursively
if (!data->insideUserHandler) {
data->insideUserHandler = true;
try {
if (!same(f_call_user_func_array
(data->systemExceptionHandlers.back(),
CREATE_VECTOR6(errnum, String(e.getMessage()), errfile,
errline, "", backtrace)),
false)) {
retval = true;
}
} catch (...) {
data->insideUserHandler = false;
if (!swallowExceptions) throw;
}
data->insideUserHandler = false;
}
}
return retval;
}
bool BaseExecutionContext::callUserErrorHandler(const Exception &e, int errnum,
bool swallowExceptions) {
switch (getErrorState()) {
case ExecutingUserHandler:
case ErrorRaisedByUserHandler:
return false;
default:
break;
}
if (!m_userErrorHandlers.empty() &&
(m_userErrorHandlers.back().second & errnum) != 0) {
int errline = 0;
String errfile;
Array backtrace;
const ExtendedException *ee = dynamic_cast<const ExtendedException*>(&e);
if (ee) {
ArrayPtr arr = ee->getBackTrace();
if (arr) {
backtrace = *arr;
Array top = backtrace.rvalAt(0);
if (!top.isNull()) {
errfile = top.rvalAt("file");
errline = top.rvalAt("line").toInt64();
}
}
}
if (backtrace.isNull()) {
backtrace = stackTraceToBackTrace(e.getStackTrace());
}
try {
ErrorStateHelper esh(this, ExecutingUserHandler);
if (!same(f_call_user_func_array
(m_userErrorHandlers.back().first,
CREATE_VECTOR6(errnum, String(e.getMessage()), errfile,
errline, "", backtrace)),
false)) {
return true;
}
} catch (...) {
if (!swallowExceptions) throw;
}
}
return false;
}
void ExecutionContext::onUnhandledException(Object e) {
String err = e.toString();
if (RuntimeOption::AlwaysLogUnhandledExceptions) {
Logger::Error("HipHop Fatal error: Uncaught exception %s", err.data());
}
RequestData::Data *data = s_request_data->data;
if (e.instanceof("exception")) {
// user thrown exception
if (!data->userExceptionHandlers.empty()) {
f_call_user_func_array(data->userExceptionHandlers.back(),
CREATE_VECTOR1(e));
return;
}
} else {
ASSERT(false);
}
data->lastError = err;
if (!RuntimeOption::AlwaysLogUnhandledExceptions) {
Logger::Error("HipHop Fatal error: Uncaught exception: %s", err.data());
}
}
bool f_is_callable(CVarRef v, bool syntax /* = false */,
Variant name /* = null */) {
if (v.isString()) {
if (!name.isNull()) name = v;
if (syntax) return true;
String str = v.toString();
int c = str.find("::");
if (c != 0 && c != String::npos && c + 2 < str.size()) {
String classname = str.substr(0, c);
String methodname = str.substr(c + 2);
return f_call_user_func_array(s_class_exists,
Array::Create(classname)) &&
ClassInfo::HasAccess(classname, methodname, true, false);
}
return f_function_exists(str);
}
if (v.is(KindOfArray)) {
Array arr = v.toArray();
if (arr.size() == 2 && arr.exists(0LL) && arr.exists(1LL)) {
Variant v0 = arr.rvalAt(0LL);
Variant v1 = arr.rvalAt(1LL);
Object obj;
bool staticCall = false;
if (v0.is(KindOfObject)) {
obj = v0.toObject();
v0 = obj->o_getClassName();
} else if (v0.isString()) {
if (!f_call_user_func_array(s_class_exists, Array::Create(v0))) {
return false;
}
staticCall = true;
}
if (v1.isString()) {
String str = v1.toString();
int c = str.find("::");
if (c != 0 && c != String::npos && c + 2 < str.size()) {
String name1 = v0.toString();
String name2 = str.substr(0, c);
ASSERT(name1.get() && name2.get());
if (name1->isame(name2.get()) ||
ClassInfo::IsSubClass(name1, name2, false)) {
staticCall = true;
v0 = name2;
v1 = str.substr(c + 2);
}
}
}
if (v0.isString() && v1.isString()) {
if (!name.isNull()) {
name = v0.toString() + "::" + v1.toString();
}
if (same(v0, s_self) || same(v0, s_parent)) {
throw NotImplementedException("augmenting class scope info");
}
return ClassInfo::HasAccess(v0, v1, staticCall, !obj.isNull());
}
}
}
if (!name.isNull()) {
name = v.toString();
}
return false;
}
void BaseExecutionContext::executeFunctions(CArrRef funcs) {
for (ArrayIter iter(funcs); iter; ++iter) {
Array callback = iter.second();
f_call_user_func_array(callback["name"], callback["args"]);
}
}
void AsioSession::OnFailed(CObjRef exception) {
ObjectData* cb = s_on_failed_cb.get();
if (cb) {
f_call_user_func_array(cb, Array::Create(exception));
}
}
Variant f_call_user_func(int _argc, CVarRef function, CArrRef _argv /* = null_array */) {
return f_call_user_func_array(function, _argv);
}
static int cmp_func(CVarRef v1, CVarRef v2, const void *data) {
Variant *callback = (Variant *)data;
return f_call_user_func_array(*callback, CREATE_VECTOR2(v1, v2));
}