int hasWordpress(TSRMLS_D)
{
if(zend_hash_exists(EG(class_table), "wp", sizeof("wp"))
&& zend_hash_exists(EG(class_table), "wp_query", sizeof("wp_query")) )
{
return 1;
}
return 0;
}
int hasMagento(TSRMLS_D)
{
if(zend_hash_exists(EG(class_table), "mage", sizeof("mage"))
&& zend_hash_exists(EG(class_table), "mage_core_controller_varien_action", sizeof("mage_core_controller_varien_action")) )
{
return 1;
}
return 0;
}
int hasYii(TSRMLS_D)
{
if(zend_hash_exists(EG(class_table), "chttprequest", sizeof("chttprequest"))
&& zend_hash_exists(EG(class_table), "capplication", sizeof("capplication"))
&& zend_hash_exists(EG(class_table), "yiibase", sizeof("yiibase")) )
{
return 1;
}
return 0;
}
/* {{{ mysqlnd_res_meta::func_leave */
static enum_func_status
MYSQLND_METHOD(mysqlnd_debug, func_leave)(MYSQLND_DEBUG * self, unsigned int line,
const char * const file)
{
char *func_name;
#ifdef MYSQLND_THREADED
MYSQLND_ZTS(self);
#endif
if ((self->flags & MYSQLND_DEBUG_DUMP_TRACE) == 0 || self->file_name == NULL) {
return PASS;
}
#ifdef MYSQLND_THREADED
if (MYSQLND_G(thread_id) != tsrm_thread_id()) {
return PASS; /* don't trace background threads */
}
#endif
if (zend_stack_count(&self->call_stack) >= self->nest_level_limit) {
return PASS;
}
zend_stack_top(&self->call_stack, (void **)&func_name);
if (func_name[0] == '\0') {
; /* don't log that function */
} else if (!zend_hash_num_elements(&self->not_filtered_functions) ||
1 == zend_hash_exists(&self->not_filtered_functions, func_name, strlen(func_name) + 1))
{
self->m->log_va(self, line, file, zend_stack_count(&self->call_stack) - 1, NULL, "<%s", func_name);
}
return zend_stack_del_top(&self->call_stack) == SUCCESS? PASS:FAIL;
}
static inline int object_common2(UNSERIALIZE_PARAMETER, long elements)
{
zval *retval_ptr = NULL;
zval fname;
if (Z_TYPE_PP(rval) != IS_OBJECT) {
return 0;
}
if (!process_nested_data(UNSERIALIZE_PASSTHRU, Z_OBJPROP_PP(rval), elements, 1)) {
return 0;
}
if (Z_OBJCE_PP(rval) != PHP_IC_ENTRY &&
zend_hash_exists(&Z_OBJCE_PP(rval)->function_table, "__wakeup", sizeof("__wakeup"))) {
INIT_PZVAL(&fname);
ZVAL_STRINGL(&fname, "__wakeup", sizeof("__wakeup") - 1, 0);
UNSERIALIZE2_G(serialize_lock)++;
call_user_function_ex(CG(function_table), rval, &fname, &retval_ptr, 0, 0, 1, NULL TSRMLS_CC);
UNSERIALIZE2_G(serialize_lock)--;
}
if (retval_ptr) {
zval_ptr_dtor(&retval_ptr);
}
if (EG(exception)) {
return 0;
}
return finish_nested_data(UNSERIALIZE_PASSTHRU);
}
/* {{{ mysqlnd_res_meta::func_enter */
static zend_bool
MYSQLND_METHOD(mysqlnd_debug, func_enter)(MYSQLND_DEBUG * self,
unsigned int line, const char * const file,
const char * const func_name, unsigned int func_name_len)
{
if ((self->flags & MYSQLND_DEBUG_DUMP_TRACE) == 0 || self->file_name == NULL) {
return FALSE;
}
if (zend_stack_count(&self->call_stack) >= self->nest_level_limit) {
return FALSE;
}
if ((self->flags & MYSQLND_DEBUG_TRACE_MEMORY_CALLS) == 0 && self->skip_functions) {
const char ** p = self->skip_functions;
while (*p) {
if (*p == func_name) {
zend_stack_push(&self->call_stack, "", sizeof(""));
return FALSE;
}
p++;
}
}
zend_stack_push(&self->call_stack, func_name, func_name_len + 1);
if (zend_hash_num_elements(&self->not_filtered_functions) &&
0 == zend_hash_exists(&self->not_filtered_functions, func_name, strlen(func_name) + 1))
{
return FALSE;
}
self->m->log_va(self, line, file, zend_stack_count(&self->call_stack) - 1, NULL, ">%s", func_name);
return TRUE;
}
/* {{{ proto void ProtocolBuffersDescriptorBuilder::addValue(ProtocolBuffers\EnumValueDescriptor $value[, bool $force = false])
*/
PHP_METHOD(protocolbuffers_enum_descriptor_builder, addValue)
{
zval *instance = getThis();
zval *value, **fields, *name;
zend_bool force = 0;
char *property;
int property_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
"O|b", &value, php_protocol_buffers_enum_value_descriptor_class_entry, &force) == FAILURE) {
return;
}
zend_mangle_property_name(&property, &property_len, (char*)"*", 1, (char*)ZEND_STRS("values"), 0);
if (zend_hash_find(Z_OBJPROP_P(instance), property, property_len, (void **)&fields) == SUCCESS) {
if (php_protocolbuffers_read_protected_property(value, ZEND_STRS("name"), &name TSRMLS_CC)) {
if (zend_hash_exists(Z_ARRVAL_PP(fields), Z_STRVAL_P(name), Z_STRLEN_P(name))) {
if (force < 1) {
zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC, "name `%s` has already registered.", Z_STRVAL_P(name));
}
efree(property);
return;
}
}
Z_ADDREF_P(value);
zend_hash_update(Z_ARRVAL_PP(fields), Z_STRVAL_P(name), Z_STRLEN_P(name)+1, &value, sizeof(zval), NULL);
}
efree(property);
}
/**
* Check if index exists on an array zval
*/
int phalcon_array_isset(const zval *arr, zval *index){
zval *copy;
if (Z_TYPE_P(arr) != IS_ARRAY) {
return 0;
}
if (Z_TYPE_P(index) == IS_NULL) {
ALLOC_ZVAL(copy);
ZVAL_ZVAL(copy, index, 1, 0);
convert_to_string(copy);
index = copy;
} else {
if (Z_TYPE_P(index) == IS_BOOL || Z_TYPE_P(index) == IS_DOUBLE) {
ALLOC_ZVAL(copy);
ZVAL_ZVAL(copy, index, 1, 0);
convert_to_long(copy);
index = copy;
}
}
if (Z_TYPE_P(index) == IS_STRING) {
return zend_hash_exists(Z_ARRVAL_P(arr), Z_STRVAL_P(index), Z_STRLEN_P(index)+1);
} else {
return zend_hash_index_exists(Z_ARRVAL_P(arr), Z_LVAL_P(index));
}
return 0;
}
/* {{{ proto void ProtocolBuffersDescriptorBuilder::addValue(ProtocolBuffers\EnumValueDescriptor $value[, bool $force = false])
*/
PHP_METHOD(protocolbuffers_enum_descriptor_builder, addValue)
{
zval *instance = getThis();
zval *value, *fields, *name;
zend_bool force = 0;
// char *property;
int property_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
"O|b", &value, php_protocol_buffers_enum_value_descriptor_class_entry, &force) == FAILURE) {
return;
}
zend_string *property_key = zend_mangle_property_name((char*)"*", 1, (char*)ZEND_STRL("values"), 0);
if ((fields=zend_hash_find(Z_OBJPROP_P(instance), property_key)) != NULL) {
if (php_protocolbuffers_read_protected_property(value, ZEND_STRL("name"), &name TSRMLS_CC)) {
zend_string *name_key = zend_string_init(Z_STRVAL_P(name), Z_STRLEN_P(name),0);
if (zend_hash_exists(Z_ARRVAL_P(fields), name_key)) {
if (force < 1) {
zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC, "name `%s` has already registered.", Z_STRVAL_P(name));
}
zend_string_release(property_key);
zend_string_release(name_key);
return;
}
}
Z_ADDREF_P(value);
zend_string *name_key = zend_string_init(Z_STRVAL_P(name), Z_STRLEN_P(name)+1,0);
zend_hash_update(Z_ARRVAL_P(fields), name_key, value);
zend_string_release(name_key);
}
zend_string_release(property_key);
}
/* {{{ php_runkit_sandbox_parent_unset_property
unset_property handler */
static void php_runkit_sandbox_parent_unset_property(zval *object, zval *member
, const zend_literal *key)
{
php_runkit_sandbox_parent_object *objval = PHP_RUNKIT_SANDBOX_PARENT_FETCHBOX(object);
zval member_copy;
if (!objval) {
return;
}
if (!objval->self->parent_access || !objval->self->parent_write) {
php_error_docref(NULL, E_WARNING, "Access to modify parent's symbol table is disallowed");
return;
}
PHP_RUNKIT_ZVAL_CONVERT_TO_STRING_IF_NEEDED(member, member_copy);
PHP_RUNKIT_SANDBOX_PARENT_BEGIN(objval)
if (zend_hash_exists(php_runkit_sandbox_parent_resolve_symbol_table(objval), Z_STRVAL_P(member), Z_STRLEN_P(member) + 1)) {
/* Simply removing the zval* causes weirdness with CVs */
zend_hash_update(php_runkit_sandbox_parent_resolve_symbol_table(objval), Z_STRVAL_P(member), Z_STRLEN_P(member) + 1, (void*)&EG(uninitialized_zval_ptr), sizeof(zval*), NULL);
}
PHP_RUNKIT_SANDBOX_PARENT_END(objval)
if (member == &member_copy) {
zval_dtor(member);
}
}
/**
* This function implements a secure old-style way to call functions
*/
static inline int phalcon_call_method_normal(zval *return_value, zval *object, char *method_name, int method_len, int check, int noreturn TSRMLS_DC){
zval *fn = NULL;
int status = FAILURE;
zend_class_entry *ce, *active_scope = NULL;
if (Z_TYPE_P(object) != IS_OBJECT) {
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Call to method %s() on a non object", method_name);
phalcon_memory_restore_stack(TSRMLS_C);
return FAILURE;
}
ce = Z_OBJCE_P(object);
if (check) {
if (!zend_hash_exists(&ce->function_table, method_name, method_len+1)) {
return SUCCESS;
}
}
if (!noreturn) {
ALLOC_INIT_ZVAL(return_value);
}
PHALCON_ALLOC_ZVAL(fn);
ZVAL_STRINGL(fn, method_name, method_len, 0);
active_scope = EG(scope);
/* Find class_entry scope */
if (ce->parent) {
phalcon_find_scope(ce, method_name, method_len TSRMLS_CC);
} else {
EG(scope) = ce;
}
status = phalcon_call_user_function(&ce->function_table, &object, fn, return_value, 0, NULL TSRMLS_CC);
if (status == FAILURE) {
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Call to undefined method %s()", method_name);
}
EG(scope) = active_scope;
ZVAL_NULL(fn);
zval_ptr_dtor(&fn);
if (!noreturn) {
zval_ptr_dtor(&return_value);
}
if (EG(exception)) {
status = FAILURE;
}
if (status == FAILURE) {
phalcon_memory_restore_stack(TSRMLS_C);
}
return status;
}
PDO_API void php_pdo_unregister_driver(pdo_driver_t *driver)
{
if (!zend_hash_exists(&module_registry, "pdo", sizeof("pdo"))) {
return;
}
zend_hash_del(&pdo_driver_hash, (char*)driver->driver_name, driver->driver_name_len);
}
static int spl_autoload(zend_string *class_name, zend_string *lc_name, const char *ext, int ext_len) /* {{{ */
{
char *class_file;
int class_file_len;
zval dummy;
zend_file_handle file_handle;
zend_op_array *new_op_array;
zval result;
int ret;
class_file_len = (int)spprintf(&class_file, 0, "%s%.*s", ZSTR_VAL(lc_name), ext_len, ext);
#if DEFAULT_SLASH != '\\'
{
char *ptr = class_file;
char *end = ptr + class_file_len;
while ((ptr = memchr(ptr, '\\', (end - ptr))) != NULL) {
*ptr = DEFAULT_SLASH;
}
}
#endif
ret = php_stream_open_for_zend_ex(class_file, &file_handle, USE_PATH|STREAM_OPEN_FOR_INCLUDE);
if (ret == SUCCESS) {
zend_string *opened_path;
if (!file_handle.opened_path) {
file_handle.opened_path = zend_string_init(class_file, class_file_len, 0);
}
opened_path = zend_string_copy(file_handle.opened_path);
ZVAL_NULL(&dummy);
if (zend_hash_add(&EG(included_files), opened_path, &dummy)) {
new_op_array = zend_compile_file(&file_handle, ZEND_REQUIRE);
zend_destroy_file_handle(&file_handle);
} else {
new_op_array = NULL;
zend_file_handle_dtor(&file_handle);
}
zend_string_release(opened_path);
if (new_op_array) {
ZVAL_UNDEF(&result);
zend_execute(new_op_array, &result);
destroy_op_array(new_op_array);
efree(new_op_array);
if (!EG(exception)) {
zval_ptr_dtor(&result);
}
efree(class_file);
return zend_hash_exists(EG(class_table), lc_name);
}
}
efree(class_file);
return 0;
} /* }}} */
static void vector_write_property(zval *object, zval *member, zval *value, void **cache_slot) /* {{{ */
{
zval tmp;
if (zend_hash_exists(&Z_OBJCE_P(object)->properties_info, Z_STR_P(member))) {
ZVAL_DOUBLE(&tmp, zval_get_double(value));
zend_get_std_object_handlers()->write_property(object, member, &tmp, cache_slot);
}
}
/**
* override __call()
* it require two parameters, func_name and args
**/
PHP_METHOD(McpackHessianClient, __call) {
zend_class_entry *ce;
zval *p_this, *args, *params, *result, *method, *tmp;
char *func_name, *ret_str = NULL;
int func_name_len = 0;
size_t return_len = 0, max_len = 1024 * 1024 * 1024;
p_this = getThis();
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, p_this,
"Osz", &ce, mcphessian_ce_ptr, &func_name, &func_name_len, &args) == FAILURE) {
php_error(E_WARNING, "parse parameters error.");
RETURN_NULL();
}
// init params
MAKE_STD_ZVAL(params);
array_init(params);
add_assoc_string(params, "jsonrpc", "2.0", 0);
add_assoc_string(params, "method", func_name, 0);
add_assoc_zval(params, "params", args);
add_assoc_string(params, "id", "123456", 0);
zval *pack = array2mcpack(params);
// post data
zval *z_url = zend_read_property(mcphessian_ce_ptr, p_this, ZEND_STRL("url"), 1 TSRMLS_CC);
convert_to_string(z_url);
char *url = Z_STRVAL_P(z_url);
php_stream_context *context = php_stream_context_alloc();
MAKE_STD_ZVAL(method);
ZVAL_STRING(method, "POST", 0);
php_stream_context_set_option(context, "http", "method", method);
php_stream_context_set_option(context, "http", "content", pack);
// read data from stream
php_stream *stream = php_stream_open_wrapper_ex(url, "rb", REPORT_ERRORS, NULL, context);
if (stream) {
ret_str = php_stream_get_line(stream, NULL, max_len, &return_len);
} else {
php_error(E_WARNING, "failed to open stream %s.", url);
RETURN_NULL();
}
MAKE_STD_ZVAL(tmp);
ZVAL_STRINGL(tmp, ret_str, return_len, 0);
result = mcpack2array(tmp);
php_stream_close(stream);
efree(ret_str);
// get result from array
zval **ret_val;
if (zend_hash_exists(Z_ARRVAL_P(result), "result", 7)) {
zend_hash_find(Z_ARRVAL_P(result), "result", 7, (void **)&ret_val);
RETURN_ZVAL(*ret_val, 1, 0);
} else {
php_error(E_WARNING, "return value illegal.");
RETURN_NULL();
}
}
/**
* Check if char index exists on an array zval
*/
int PHALCON_FASTCALL phalcon_array_isset_string(const zval *arr, char *index, uint index_length){
if (Z_TYPE_P(arr) != IS_ARRAY) {
return 0;
} else {
if (!zend_hash_num_elements(Z_ARRVAL_P(arr))) {
return 0;
}
}
return zend_hash_exists(Z_ARRVAL_P(arr), index, index_length);
}
ZEND_API int zend_ts_hash_exists(TsHashTable *ht, zend_string *key)
{
int retval;
begin_read(ht);
retval = zend_hash_exists(TS_HASH(ht), key);
end_read(ht);
return retval;
}
PHP_METHOD(jz_data, __isset) {
zend_string *name;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &name) == FAILURE) {
return;
} else {
zval *prop = zend_read_property(jz_data_class_entry, getThis(), ZEND_STRL(JZ_DATA_PROPERT_NAME), 1, NULL);
RETURN_BOOL(zend_hash_exists(Z_ARRVAL_P(prop), name));
}
}
/** {{{ proto public Yaf_Config_Simple::__isset($name)
*/
PHP_METHOD(yaf_config_simple, __isset) {
zend_string *name;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &name) == FAILURE) {
return;
} else {
zval *prop = zend_read_property(yaf_config_simple_ce, getThis(), ZEND_STRL(YAF_CONFIG_PROPERT_NAME), 1, NULL);
RETURN_BOOL(zend_hash_exists(Z_ARRVAL_P(prop), name));
}
}
static int32_t qb_validate_operands_fetch_constant(qb_compiler_context *cxt, qb_op_factory *f, qb_primitive_type expr_type, uint32_t flags, qb_operand *operands, uint32_t operand_count, qb_result_destination *result_destination) {
USE_TSRM
qb_operand *scope = &operands[0], *name = &operands[1];
if(scope->type == QB_OPERAND_ZEND_STATIC_CLASS) {
// validation at runtime
} else {
zend_class_entry *ce = NULL;
HashTable *ht;
const char *name_str = Z_STRVAL_P(name->constant);
uint32_t name_len = Z_STRLEN_P(name->constant);
if(scope->type == QB_OPERAND_ZEND_CLASS) {
ce = scope->zend_class;
} else if(scope->type == QB_OPERAND_ZVAL) {
if(Z_TYPE_P(scope->constant) == IS_STRING) {
ce = zend_fetch_class_by_name(Z_STRVAL_P(scope->constant), Z_STRLEN_P(scope->constant), NULL, 0 TSRMLS_CC);
} else {
ce = cxt->zend_op_array->scope;
}
}
if(ce) {
ht = &ce->constants_table;
} else {
ht = EG(zend_constants);
}
if(zend_hash_exists(ht, name_str, name_len + 1)) {
return TRUE;
}
// see if the name has a namespace attached
if(qb_strip_namespace(&name_str, &name_len)) {
if(zend_hash_exists(ht, name_str, name_len + 1)) {
return TRUE;
}
}
// see if it's a special QB constant
if(qb_get_special_constant(cxt, name_str, name_len)) {
return TRUE;
} else {
qb_report_undefined_constant_exception(cxt->line_id, ce, Z_STRVAL_P(name->constant));
}
}
return FALSE;
}
/* {{{ proto bool MongoDBRef::isRef(mixed ref)
Checks if $ref has a $ref and $id property/key */
PHP_METHOD(MongoDBRef, isRef)
{
zval *ref;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &ref) == FAILURE) {
return;
}
if (IS_SCALAR_P(ref)) {
RETURN_FALSE;
}
/* check that $ref and $id fields exists */
if (zend_hash_exists(HASH_P(ref), "$ref", strlen("$ref") + 1) && zend_hash_exists(HASH_P(ref), "$id", strlen("$id") + 1)) {
/* good enough */
RETURN_TRUE;
}
RETURN_FALSE;
}
/**
* Check if index exists on an array zval
*/
int PHALCON_FASTCALL phalcon_array_isset(const zval *arr, zval *index) {
zval *copy;
int exists, type, copied = 0;
if (Z_TYPE_P(arr) != IS_ARRAY) {
return 0;
} else {
if (!zend_hash_num_elements(Z_ARRVAL_P(arr))) {
return 0;
}
}
if (Z_TYPE_P(index) == IS_NULL) {
ALLOC_INIT_ZVAL(copy);
ZVAL_ZVAL(copy, index, 1, 0);
convert_to_string(copy);
index = copy;
copied = 1;
} else {
if (Z_TYPE_P(index) == IS_BOOL || Z_TYPE_P(index) == IS_DOUBLE) {
ALLOC_INIT_ZVAL(copy);
ZVAL_ZVAL(copy, index, 0, 0);
convert_to_long(copy);
index = copy;
copied = 1;
}
}
if (Z_TYPE_P(index) == IS_STRING) {
if((type = is_numeric_string(Z_STRVAL_P(index), Z_STRLEN_P(index), NULL, NULL, 0))){
if (type == IS_LONG) {
ALLOC_INIT_ZVAL(copy);
ZVAL_ZVAL(copy, index, 1, 0);
convert_to_long(copy);
index = copy;
copied = 1;
}
}
}
if (Z_TYPE_P(index) == IS_STRING) {
exists = zend_hash_exists(Z_ARRVAL_P(arr), Z_STRVAL_P(index), Z_STRLEN_P(index) + 1);
} else {
exists = zend_hash_index_exists(Z_ARRVAL_P(arr), Z_LVAL_P(index));
}
if (copied) {
zval_ptr_dtor(©);
}
return exists;
}
/**
* Call methods that require parameters in a old-style secure way
*/
inline int phalcon_call_method_params_normal(zval *return_value, zval *object, char *method_name, int method_len, zend_uint param_count, zval *params[], int check, int noreturn TSRMLS_DC){
zval *fn = NULL;
int status = FAILURE;
zend_class_entry *ce, *active_scope = NULL;
if (check) {
if (!zend_hash_exists(&Z_OBJCE_P(object)->function_table, method_name, method_len+1)) {
return SUCCESS;
}
}
if (!noreturn) {
ALLOC_INIT_ZVAL(return_value);
}
PHALCON_ALLOC_ZVAL(fn);
ZVAL_STRINGL(fn, method_name, method_len, 1);
if (Z_TYPE_P(object) == IS_OBJECT) {
active_scope = EG(scope);
ce = Z_OBJCE_P(object);
phalcon_find_scope(ce, method_name, method_len TSRMLS_CC);
status = PHALCON_CALL_USER_FUNCTION(&ce->function_table, &object, fn, return_value, param_count, params TSRMLS_CC);
if (status == FAILURE) {
EG(scope) = active_scope;
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Call to undefined method %s() on class %s", Z_STRVAL_P(fn), Z_OBJCE_P(object)->name);
status = FAILURE;
}
EG(scope) = active_scope;
} else {
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Call to method %s() on a non object", Z_STRVAL_P(fn));
status = FAILURE;
}
zval_ptr_dtor(&fn);
if (!noreturn) {
zval_ptr_dtor(&return_value);
return_value = NULL;
}
if (EG(exception)){
status = FAILURE;
}
if (status == FAILURE) {
phalcon_memory_restore_stack(TSRMLS_C);
}
return status;
}
ZEND_API int _zend_hash_add_or_update(HashTable *ht, const char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC) {
if (nKeyLength <= 0) {
return FAILURE;
}
assert(arKey[nKeyLength - 1] == '\0');
if ((flag & HASH_ADD) && zend_hash_exists(ht, arKey, nKeyLength)) {
return FAILURE;
}
HPHP::String key(arKey, nKeyLength - 1, HPHP::CopyString);
ht->zSet(key.get(), (*(zval**)pData));
return SUCCESS;
}
/**
* Execute a file only once
* @return Value
*/
Value File::once()
{
// skip if the path is invalid
if (!_path) return nullptr;
// we need the tsrm_ls variable (@todo would it be better if this was a member?)
TSRMLS_FETCH();
// check if this file was already included
if (zend_hash_exists(&EG(included_files), _path, ::strlen(_path) + 1)) return nullptr;
// execute the file
return execute();
}
// time critical
bool PHPQt::methodExists(const zend_class_entry* ce_ptr, const char* methodname)
{
if(ce_ptr == NULL)
pError() << "no class entry, could not check for message " << methodname;
char* lcname = zend_str_tolower_dup(methodname, strlen(methodname));
if(zend_hash_exists(const_cast<HashTable*>(&ce_ptr->function_table), lcname, strlen(methodname)+1)){
return true;
}
efree(lcname);
return false;
}
void uopz_unset_mock(zend_string *clazz) { /* {{{ */
zend_string *key = zend_string_tolower(clazz);
if (!zend_hash_exists(&UOPZ(mocks), key)) {
uopz_exception(
"the class provided (%s) has no mock set",
ZSTR_VAL(clazz));
zend_string_release(key);
return;
}
zend_hash_del(&UOPZ(mocks), key);
zend_string_release(key);
} /* }}} */
/* {{{ apc_iterator_search_match
* Verify if the key matches our search parameters
*/
static int apc_iterator_search_match(apc_iterator_t *iterator, apc_cache_slot_t **slot) {
int rval = 1;
#ifdef ITERATOR_PCRE
if (iterator->regex) {
rval = (pcre_exec(iterator->re, NULL, ZSTR_VAL((*slot)->key.str), ZSTR_LEN((*slot)->key.str), 0, 0, NULL, 0) >= 0);
}
#endif
if (iterator->search_hash) {
rval = zend_hash_exists(iterator->search_hash, (*slot)->key.str);
}
return rval;
}
PDO_API int php_pdo_register_driver(pdo_driver_t *driver)
{
if (driver->api_version != PDO_DRIVER_API) {
zend_error(E_ERROR, "PDO: driver %s requires PDO API version %ld; this is PDO version %d",
driver->driver_name, driver->api_version, PDO_DRIVER_API);
return FAILURE;
}
if (!zend_hash_exists(&module_registry, "pdo", sizeof("pdo"))) {
zend_error(E_ERROR, "You MUST load PDO before loading any PDO drivers");
return FAILURE; /* NOTREACHED */
}
return zend_hash_add(&pdo_driver_hash, (char*)driver->driver_name, driver->driver_name_len,
(void**)&driver, sizeof(pdo_driver_t *), NULL);
}
/**
* Finds the correct scope to execute the function
*/
int phalcon_find_scope(zend_class_entry *ce, char *method_name, int method_len TSRMLS_DC){
char *lcname = zend_str_tolower_dup(method_name, method_len);
while (ce) {
if (zend_hash_exists(&ce->function_table, lcname, method_len+1)) {
EG(scope) = ce;
efree(lcname);
return SUCCESS;
}
ce = ce->parent;
}
if (lcname) {
efree(lcname);
}
return FAILURE;
}
