PHP_METHOD(air_mysql_waiter, step_1) {
AIR_INIT_THIS;
zval *context = zend_read_property(Z_OBJCE_P(self), self, ZEND_STRL("_context"), 0 TSRMLS_CC);
zval *wait_pool = air_arr_find(context, ZEND_STRS("pool"));;
zval *timeout;
MAKE_STD_ZVAL(timeout);
ZVAL_LONG(timeout, 0);
zend_class_entry *mysqli_ce = air_get_ce(ZEND_STRL("mysqli") TSRMLS_CC);
zval *mysqli;
zval *errors, *reads, *rejects;
MAKE_STD_ZVAL(errors);
ZVAL_ZVAL(errors, wait_pool, 1, 0);
MAKE_STD_ZVAL(reads);
ZVAL_ZVAL(reads, wait_pool, 1, 0);
MAKE_STD_ZVAL(rejects);
ZVAL_ZVAL(rejects, wait_pool, 1, 0);
zval **poll_params[4] = {&reads, &errors, &rejects, &timeout};
zval *count;
air_call_static_method(mysqli_ce, "poll", &count, 4, poll_params);
if(Z_LVAL_P(count)){
add_assoc_long(context, "step", 2);
}
add_assoc_zval(context, "reads", reads);
zval_ptr_dtor(&errors);
zval_ptr_dtor(&rejects);
zval_ptr_dtor(&timeout);
zval_ptr_dtor(&count);
}
/**
* Unsets zval index from array
*/
int phalcon_array_unset(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_del(Z_ARRVAL_P(arr), Z_STRVAL_P(index), Z_STRLEN_P(index)+1);
} else {
return zend_hash_index_del(Z_ARRVAL_P(arr), Z_LVAL_P(index));
}
return 0;
}
/**
* 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;
}
/**
* Unsets zval index from array
*/
int PHALCON_FASTCALL phalcon_array_unset(zval **arr, zval *index, int flags) {
zval *copy;
int exists, copied = 0;
if (Z_TYPE_PP(arr) != IS_ARRAY) {
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, 1, 0);
convert_to_long(copy);
index = copy;
copied = 1;
}
}
if ((flags & PH_SEPARATE) == PH_SEPARATE) {
if (Z_REFCOUNT_PP(arr) > 1) {
zval *new_zv;
Z_DELREF_PP(arr);
ALLOC_ZVAL(new_zv);
INIT_PZVAL_COPY(new_zv, *arr);
*arr = new_zv;
zval_copy_ctor(new_zv);
}
}
if (Z_TYPE_P(index) == IS_STRING) {
exists = zend_hash_del(Z_ARRVAL_PP(arr), Z_STRVAL_P(index), Z_STRLEN_P(index) + 1);
} else {
exists = zend_hash_index_del(Z_ARRVAL_PP(arr), Z_LVAL_P(index));
}
if (copied) {
zval_ptr_dtor(©);
}
return exists;
}
/* {{{ proto ProtocolBuffers\EnumDescriptor ProtocolBuffersDescriptorBuilder::build()
*/
PHP_METHOD(protocolbuffers_enum_descriptor_builder, build)
{
zval *result, *container, *fields, *entry, *key, *value;
char *property;
int property_len;
HashPosition pos;
// MAKE_STD_ZVAL(result);
object_init_ex(result, php_protocol_buffers_enum_descriptor_class_entry);
// MAKE_STD_ZVAL(container);
array_init(container);
zend_string *property_key = zend_mangle_property_name((char*)"*", 1, ZEND_STRL("values"), 0);
if ((fields=zend_hash_find(Z_OBJPROP_P(getThis()), property_key)) != NULL) {
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(fields), &pos);
while ((entry=zend_hash_get_current_data_ex(Z_ARRVAL_P(fields), &pos)) != NULL) {
zval *tmp = NULL;
// MAKE_STD_ZVAL(tmp);
php_protocolbuffers_read_protected_property(entry, ZEND_STRL("name"), &key TSRMLS_CC);
php_protocolbuffers_read_protected_property(entry, ZEND_STRL("value"), &value TSRMLS_CC);
ZVAL_ZVAL(tmp, value, 1, 0);
zend_string *key_name = zend_string_init(Z_STRVAL_P(key),Z_STRLEN_P(key),0);
zend_hash_update(Z_ARRVAL_P(container), key_name, tmp);
zend_hash_move_forward_ex(Z_ARRVAL_P(fields), &pos);
}
}
efree(property);
php_protocolbuffers_set_protected_property(result, ZEND_STRL("values"), container TSRMLS_CC);
RETURN_ZVAL(result, 0, 1);
}
/* {{{ proto ProtocolBuffers\EnumDescriptor ProtocolBuffersDescriptorBuilder::build()
*/
PHP_METHOD(protocolbuffers_enum_descriptor_builder, build)
{
zval *result, *container, **fields, **entry, *key, *value;
char *property;
int property_len;
HashPosition pos;
MAKE_STD_ZVAL(result);
object_init_ex(result, php_protocol_buffers_enum_descriptor_class_entry);
MAKE_STD_ZVAL(container);
array_init(container);
zend_mangle_property_name(&property, &property_len, (char*)"*", 1, (char*)ZEND_STRS("values"), 0);
if (zend_hash_find(Z_OBJPROP_P(getThis()), property, property_len, (void **)&fields) == SUCCESS) {
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(fields), &pos);
while (zend_hash_get_current_data_ex(Z_ARRVAL_PP(fields), (void **)&entry, &pos) == SUCCESS) {
zval *tmp = NULL;
MAKE_STD_ZVAL(tmp);
php_protocolbuffers_read_protected_property(*entry, ZEND_STRS("name"), &key TSRMLS_CC);
php_protocolbuffers_read_protected_property(*entry, ZEND_STRS("value"), &value TSRMLS_CC);
ZVAL_ZVAL(tmp, value, 1, 0);
zend_hash_update(Z_ARRVAL_P(container), Z_STRVAL_P(key), Z_STRLEN_P(key), &tmp, sizeof(zval), NULL);
zend_hash_move_forward_ex(Z_ARRVAL_PP(fields), &pos);
}
}
efree(property);
php_protocolbuffers_set_protected_property(result, ZEND_STRS("values"), container TSRMLS_CC);
RETURN_ZVAL(result, 0, 1);
}
/**
* Phalcon\Db constructor
*
* @param stdClass $descriptor
*/
PHP_METHOD(Phalcon_Db, __construct){
zval *descriptor = NULL;
zval *t0 = NULL, *t1 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &descriptor) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
phalcon_update_property_zval(this_ptr, SL("_descriptor"), descriptor TSRMLS_CC);
PHALCON_OBSERVE_VAR(t0);
phalcon_read_static_property(&t0, SL("phalcon\\db"), SL("_connectionConsecutive") TSRMLS_CC);
PHALCON_SEPARATE_NMO(t0);
PHALCON_ALLOC_ZVAL_MM(t1);
ZVAL_ZVAL(t1, t0, 1, 0);
increment_function(t0);
phalcon_update_static_property(SL("phalcon\\db"), SL("_connectionConsecutive"), t0 TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_connectionId"), t1 TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* List all tables on a database
*
*
*
* @param string $schemaName
* @return array
*/
PHP_METHOD(Phalcon_Db_Adapter_Mysql, listTables){
zval *schema_name = NULL, *sql = NULL, *tables = NULL, *all_tables = NULL, *table = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL;
zval *t0 = NULL;
zval *a0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &schema_name) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!schema_name) {
PHALCON_INIT_VAR(schema_name);
ZVAL_NULL(schema_name);
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_STATIC_PARAMS_1(r0, "phalcon_db_dialect_mysql", "listtables", schema_name);
PHALCON_CPY_WRT(sql, r0);
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 2);
PHALCON_CALL_METHOD_PARAMS_2(r1, this_ptr, "fetchall", sql, t0, PHALCON_NO_CHECK);
PHALCON_CPY_WRT(tables, r1);
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(all_tables, a0);
if (phalcon_valid_foreach(tables TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(tables);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_321f_1:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_321f_1;
}
PHALCON_INIT_VAR(table);
ZVAL_ZVAL(table, *hd, 1, 0);
PHALCON_INIT_VAR(r2);
phalcon_array_fetch_long(&r2, table, 0, PHALCON_NOISY TSRMLS_CC);
phalcon_array_append(&all_tables, r2, PHALCON_SEPARATE_PLZ TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_321f_1;
fee_321f_1:
if(0){}
} else {
return;
}
RETURN_CTOR(all_tables);
}
/**
* List all tables on a database
*
* @param string $schemaName
* @return array
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, listTables){
zval *schema_name = NULL, *sql = NULL, *tables = NULL, *all_tables = NULL, *table = NULL;
zval *t0 = NULL, *t1 = NULL;
zval *r0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &schema_name) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!schema_name) {
PHALCON_ALLOC_ZVAL_MM(schema_name);
ZVAL_NULL(schema_name);
}
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_dialect"), PH_NOISY_CC);
PHALCON_INIT_VAR(sql);
PHALCON_CALL_METHOD_PARAMS_1(sql, t0, "listtables", schema_name, PH_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_get_class_constant(t1, phalcon_db_ce, SL("FETCH_NUM") TSRMLS_CC);
PHALCON_INIT_VAR(tables);
PHALCON_CALL_METHOD_PARAMS_2(tables, this_ptr, "fetchall", sql, t1, PH_NO_CHECK);
PHALCON_INIT_VAR(all_tables);
array_init(all_tables);
if (!phalcon_valid_foreach(tables TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(tables);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_7f5d_3:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_7f5d_3;
}
PHALCON_INIT_VAR(table);
ZVAL_ZVAL(table, *hd, 1, 0);
PHALCON_INIT_VAR(r0);
phalcon_array_fetch_long(&r0, table, 0, PH_NOISY_CC);
phalcon_array_append(&all_tables, r0, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_7f5d_3;
fee_7f5d_3:
if(0){}
RETURN_CTOR(all_tables);
}
/**
* Uncamelize strings which are camelized
*
*<code>
* echo Phalcon\Text::camelize('CocoBongo'); //coco_bongo
*</code>
*
* @param string $str
* @return string
*/
PHP_METHOD(Phalcon_Text, uncamelize){
zval *str = NULL, *patterns = NULL, *replacement = NULL, *pattern = NULL, *match_pattern = NULL;
zval *pattern_replace = NULL, *lower_pattern = NULL, *lower_str = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &str) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(patterns);
array_init(patterns);
add_assoc_stringl_ex(patterns, SL("/(?<=(?:[A-Z]))([A-Z]+)([A-Z][A-z])/")+1, SL("\\1_\\2"), 1);
add_assoc_stringl_ex(patterns, SL("/(?<=(?:[a-z]))([A-Z])/")+1, SL("_\\1"), 1);
if (!phalcon_valid_foreach(patterns TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(patterns);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_f8ee_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_f8ee_0;
}
PHALCON_INIT_VAR(pattern);
PHALCON_GET_FOREACH_KEY(pattern, ah0, hp0);
PHALCON_INIT_VAR(replacement);
ZVAL_ZVAL(replacement, *hd, 1, 0);
PHALCON_INIT_VAR(match_pattern);
PHALCON_CALL_FUNC_PARAMS_2(match_pattern, "preg_match", pattern, str);
if (zend_is_true(match_pattern)) {
PHALCON_INIT_VAR(pattern_replace);
PHALCON_CALL_FUNC_PARAMS_3(pattern_replace, "preg_replace", pattern, replacement, str);
PHALCON_INIT_VAR(lower_pattern);
PHALCON_CALL_FUNC_PARAMS_1(lower_pattern, "strtolower", pattern_replace);
RETURN_CTOR(lower_pattern);
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_f8ee_0;
fee_f8ee_0:
PHALCON_INIT_VAR(lower_str);
PHALCON_CALL_FUNC_PARAMS_1(lower_str, "strtolower", str);
RETURN_CTOR(lower_str);
}
PHP_METHOD(Phalcon_Flash, _showMessage){
zval *message = NULL, *classes = NULL, *css_classes = NULL, *msg = NULL;
zval *c0 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL;
zval *t0 = NULL, *t1 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &message, &classes) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(classes) == IS_ARRAY) {
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, " ", 1);
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_fast_join(r0, c0, classes TSRMLS_CC);
PHALCON_CPY_WRT(css_classes, r0);
} else {
PHALCON_CPY_WRT(css_classes, classes);
}
if (Z_TYPE_P(message) == IS_ARRAY) {
if (phalcon_valid_foreach(message TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(message);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_3b3c_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_3b3c_0;
}
PHALCON_INIT_VAR(msg);
ZVAL_ZVAL(msg, *hd, 1, 0);
PHALCON_INIT_VAR(r1);
PHALCON_INIT_VAR(t0);
zend_get_constant("PHP_EOL", strlen("PHP_EOL"), t0 TSRMLS_CC);
PHALCON_CONCAT_SVSVSV(r1, "<div class=\"", css_classes, "\">", msg, "</div>", t0);
zend_print_zval(r1, 1);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_3b3c_0;
fee_3b3c_0:
if(0){}
} else {
return;
}
} else {
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_ALLOC_ZVAL_MM(t1);
zend_get_constant("PHP_EOL", strlen("PHP_EOL"), t1 TSRMLS_CC);
PHALCON_CONCAT_SVSVSV(r2, "<div class=\"", css_classes, "\">", message, "</div>", t1);
zend_print_zval(r2, 1);
}
PHALCON_MM_RESTORE();
}
/**
* Renders a view using the template engine
*
* @param string $path
* @param array $params
* @param bool $mustClean
*/
PHP_METHOD(Phalcon_Mvc_View_Engine_Php, render){
zval *path = NULL, *params = NULL, *must_clean = NULL, *value = NULL, *key = NULL, *contents = NULL;
zval *view = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &path, ¶ms, &must_clean) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(must_clean) == IS_BOOL && Z_BVAL_P(must_clean)) {
PHALCON_CALL_FUNC_NORETURN("ob_clean");
}
if (!phalcon_valid_foreach(params TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(params);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_1897_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_1897_0;
}
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
if (phalcon_set_symbol(key, value TSRMLS_CC) == FAILURE){
return;
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_1897_0;
fee_1897_0:
if (phalcon_require(path TSRMLS_CC) == FAILURE) {
return;
}
if (Z_TYPE_P(must_clean) == IS_BOOL && Z_BVAL_P(must_clean)) {
PHALCON_INIT_VAR(contents);
PHALCON_CALL_FUNC(contents, "ob_get_contents");
PHALCON_INIT_VAR(view);
phalcon_read_property(&view, this_ptr, SL("_view"), PH_NOISY_CC);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(view, "setcontent", contents, PH_NO_CHECK);
}
PHALCON_MM_RESTORE();
}
bool pq_callPHPFunction(const QString &fn_name, QObject *sender, QEvent *event)
{
#ifdef PQDEBUG
PQDBG2("pq_callPHPFunction()", fn_name);
#endif
TSRMLS_FETCH();
if(!PHPQt5::acceptedPHPFunctions.contains(fn_name)) {
//QMessageBox::warning(0, "callPHPFunction", QString("callPHPFunction: cannot call function %1($event)").arg(fn_name));
return false;
}
pq_access_function_entry afe = PHPQt5::acceptedPHPFunctions.value(fn_name);
zval *args[2];
zval *retzval = NULL;
zval *pqzobj = PHPQt5::objectFactory()->getZObject(sender);
zval *zevent = PHPQt5::pq_qevent_to_zobject(event TSRMLS_CC);
int handle = Z_OBJVAL_P(zevent).handle;
bool retval = false;
MAKE_STD_ZVAL(args[0]);
MAKE_STD_ZVAL(args[1]);
MAKE_STD_ZVAL(retzval);
ZVAL_ZVAL(args[0], pqzobj, 1, 0);
ZVAL_ZVAL(args[1], zevent, 1, 0);
PHPQt5::pq_eventHash.insert(handle, pq_event_wrapper{zevent, event});
call_user_function(EG(function_table), &afe.zo, afe.zfn_name, retzval, 2, args TSRMLS_CC);
PHPQt5::pq_eventHash.remove(handle);
if(retzval != NULL
&& Z_TYPE_P(retzval) == IS_BOOL)
{
retval = Z_BVAL_P(retzval);
}
zval_ptr_dtor(&args[0]);
zval_ptr_dtor(&args[1]);
zval_ptr_dtor(&zevent);
zval_ptr_dtor(&retzval);
return retval;
}
/**
* Sets the default descriptor for database connections.
*
*
*
* @param array $options
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Pool, setDefaultDescriptor){
zval *options = NULL, *descriptor = NULL, *value = NULL, *key = NULL;
zval *i0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &options) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(options) != IS_ARRAY) {
if (Z_TYPE_P(options) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The parameter 'options' must be an Array or Object");
return;
}
}
if (Z_TYPE_P(options) == IS_ARRAY) {
PHALCON_ALLOC_ZVAL_MM(i0);
object_init(i0);
PHALCON_CPY_WRT(descriptor, i0);
if (phalcon_valid_foreach(options TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(options);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_162f_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_162f_0;
} else {
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
}
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
phalcon_update_property_zval_zval(descriptor, key, value TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_162f_0;
fee_162f_0:
if(0){}
} else {
return;
}
} else {
PHALCON_CPY_WRT(descriptor, options);
}
phalcon_update_static_property(SL("Phalcon_Db_Pool"), SL("_defaultDescriptor"), descriptor TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Commits the internal transaction
*
*/
PHP_METHOD(Phalcon_Logger_Adapter_File, commit){
zval *message = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_transaction"), PH_NOISY_CC);
if (!zend_is_true(t0)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_logger_exception_ce, "There is no active transaction");
return;
}
phalcon_update_property_bool(this_ptr, SL("_transaction"), 0 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, SL("_quenue"), PH_NOISY_CC);
if (!phalcon_valid_foreach(t1 TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(t1);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_654f_1:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_654f_1;
}
PHALCON_INIT_VAR(message);
ZVAL_ZVAL(message, *hd, 1, 0);
PHALCON_INIT_VAR(t2);
phalcon_read_property(&t2, this_ptr, SL("_fileHandler"), PH_NOISY_CC);
PHALCON_INIT_VAR(r0);
PHALCON_CALL_METHOD(r0, message, "getmessage", PH_NO_CHECK);
PHALCON_INIT_VAR(r1);
PHALCON_CALL_METHOD(r1, message, "gettype", PH_NO_CHECK);
PHALCON_INIT_VAR(r2);
PHALCON_CALL_METHOD(r2, message, "gettime", PH_NO_CHECK);
PHALCON_INIT_VAR(r3);
PHALCON_CALL_METHOD_PARAMS_3(r3, this_ptr, "_applyformat", r0, r1, r2, PH_NO_CHECK);
PHALCON_INIT_VAR(t3);
zend_get_constant(SL("PHP_EOL"), t3 TSRMLS_CC);
PHALCON_INIT_VAR(r4);
PHALCON_CONCAT_VV(r4, r3, t3);
PHALCON_CALL_FUNC_PARAMS_2_NORETURN("fputs", t2, r4);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_654f_1;
fee_654f_1:
if(0){}
PHALCON_MM_RESTORE();
}
/** {{{ zval * php_lua_closure_instance(zval *instance, long ref_id, zval *lua_obj)
*/
zval* php_lua_closure_instance(zval *instance, long ref_id, zval *lua_obj) {
lua_closure_object *objval;
object_init_ex(instance, lua_closure_ce);
objval = php_lua_closure_object_from_zend_object(Z_OBJ_P(instance));
objval->closure = ref_id;
ZVAL_ZVAL(&(objval->lua), lua_obj, 1, 0);
return instance;
}
static void
php_jq_filter(zval **return_value, jq_state *jq, jv json, int flags TSRMLS_DC)
{
jv result;
jq_start(jq, jv_copy(json), 0);
if (jv_is_valid(result = jq_next(jq))) {
int multiple = 0;
while (1) {
zval *zv;
ALLOC_INIT_ZVAL(zv);
if (flags == JQ_OPT_RAW) {
if (jv_get_kind(result) == JV_KIND_STRING) {
ZVAL_STRING(zv, jv_string_value(result), 1);
} else {
jv dump = jv_dump_string(result, 0);
if (jv_is_valid(dump)) {
ZVAL_STRING(zv, jv_string_value(dump), 1);
}
jv_free(dump);
}
} else {
php_jv_dump(&zv, result TSRMLS_CC);
}
if (!jv_is_valid(result = jq_next(jq))) {
if (multiple) {
zend_hash_next_index_insert(Z_ARRVAL_PP(return_value),
&zv, sizeof(zv), NULL);
} else {
ZVAL_ZVAL(*return_value, zv, 1, 1);
}
break;
}
if (!multiple) {
multiple = 1;
array_init(*return_value);
}
zend_hash_next_index_insert(Z_ARRVAL_PP(return_value),
&zv, sizeof(zv), NULL);
}
} else {
jv_free(result);
if (PHP_JQ_G(display_errors)) {
PHP_JQ_ERR(E_WARNING, "filter parse error");
}
ZVAL_BOOL(*return_value, 0);
}
}
/**
* Fetch the key for the current element (optional, may be NULL). The key
* should be written into the provided zval* using the ZVAL_* macros. If
* this handler is not provided auto-incrementing integer keys will be
* used.
* @param iter
* @param key
*/
void IteratorImpl::key(zend_object_iterator *iter, zval *key)
{
// retrieve the key
Value retval(self(iter)->key());
// detach the underlying zval
Zval val = retval.detach(true);
// copy it to the key
ZVAL_ZVAL(key, val, 1, 1);
}
/**
* Reads class constant from string name and returns its value
*/
int zephir_get_class_constant(zval *return_value, zend_class_entry *ce, char *constant_name, unsigned int constant_length TSRMLS_DC) {
zval **result_ptr;
if (zephir_hash_find(&ce->constants_table, constant_name, constant_length, (void **) &result_ptr) != SUCCESS) {
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Undefined class constant '%s::%s'", ce->name, constant_name);
return FAILURE;
}
ZVAL_ZVAL(return_value, *result_ptr, 1, 0);
return SUCCESS;
}
/*
*******************************************************************************************************
* Wrapper function to perform an aerospike_key_exists within the C client.
*
* @param as_object_p The C client's aerospike object.
* @param as_key_p The C client's as_key that identifies the record.
* @param metadata_p The return metadata for the exists/getMetadata API to be
* populated by this function.
* @param options_p The user's optional policy options to be used if set, else defaults.
* @param error_p The as_error to be populated by the function
* with the encountered error if any.
*
*******************************************************************************************************
*/
extern as_status
aerospike_php_exists_metadata(aerospike* as_object_p,
zval* key_record_p,
zval* metadata_p,
zval* options_p,
as_error* error_p) {
as_status status = AEROSPIKE_OK;
as_key as_key_for_put_record;
int16_t initializeKey = 0;
if ((!as_object_p) || (!key_record_p)) {
status = AEROSPIKE_ERR;
goto exit;
}
if (PHP_TYPE_ISNOTARR(key_record_p) ||
((options_p) && (PHP_TYPE_ISNOTARR(options_p)))) {
status = AEROSPIKE_ERR_PARAM;
DEBUG_PHP_EXT_ERROR("input parameters (type) for exist/getMetdata function not proper.");
goto exit;
}
if (PHP_TYPE_ISNOTARR(metadata_p)) {
zval* metadata_arr_p = NULL;
MAKE_STD_ZVAL(metadata_arr_p);
array_init(metadata_arr_p);
ZVAL_ZVAL(metadata_p, metadata_arr_p, 1, 1);
}
if (AEROSPIKE_OK != (status =
aerospike_transform_iterate_for_rec_key_params(Z_ARRVAL_P(key_record_p),
&as_key_for_put_record, &initializeKey))) {
DEBUG_PHP_EXT_ERROR("unable to iterate through exists/getMetadata key params");
goto exit;
}
if (AEROSPIKE_OK != (status =
aerospike_record_operations_exists(as_object_p, &as_key_for_put_record,
error_p, metadata_p, options_p))) {
DEBUG_PHP_EXT_ERROR("exists/getMetadata: unable to fetch the record");
goto exit;
}
exit:
if (initializeKey) {
as_key_destroy(&as_key_for_put_record);
}
return status;
}
/**
* Gets attached files as Phalcon_Request_File instances
*
* @return array
*/
PHP_METHOD(Phalcon_Request, getUploadedFiles){
zval *super_files = NULL, *files = NULL, *file = NULL;
zval *g0 = NULL;
zval *r0 = NULL;
zval *a0 = NULL, *a1 = NULL;
zval *i0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_get_global(&g0, "_FILES", sizeof("_FILES") TSRMLS_CC);
PHALCON_CPY_WRT(super_files, g0);
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_fast_count(r0, super_files TSRMLS_CC);
if (zend_is_true(r0)) {
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(files, a0);
if (phalcon_valid_foreach(super_files TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(super_files);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_9aea_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_9aea_0;
}
PHALCON_INIT_VAR(file);
ZVAL_ZVAL(file, *hd, 1, 0);
PHALCON_INIT_VAR(i0);
object_init_ex(i0, phalcon_request_file_ce);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i0, "__construct", file, PHALCON_CHECK);
phalcon_array_append(&files, i0, PHALCON_SEPARATE_PLZ TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_9aea_0;
fee_9aea_0:
if(0){}
} else {
return;
}
PHALCON_RETURN_CTOR(files);
}
PHALCON_INIT_VAR(a1);
array_init(a1);
PHALCON_RETURN_CTOR(a1);
}
/**
* Check if HTTP method match any of the passed methods
*
* @param string|array $methods
*/
PHP_METHOD(Phalcon_Http_Request, isMethod){
zval *methods = NULL, *http_method = NULL, *is_equals = NULL, *method = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &methods) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(http_method);
PHALCON_CALL_METHOD(http_method, this_ptr, "getmethod", PH_NO_CHECK);
if (Z_TYPE_P(methods) == IS_STRING) {
PHALCON_INIT_VAR(is_equals);
is_equal_function(is_equals, methods, http_method TSRMLS_CC);
RETURN_NCTOR(is_equals);
} else {
if (!phalcon_valid_foreach(methods TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(methods);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_ac06_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_ac06_0;
}
PHALCON_INIT_VAR(method);
ZVAL_ZVAL(method, *hd, 1, 0);
PHALCON_INIT_VAR(is_equals);
is_equal_function(is_equals, method, http_method TSRMLS_CC);
if (Z_TYPE_P(is_equals) == IS_BOOL && Z_BVAL_P(is_equals)) {
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_ac06_0;
fee_ac06_0:
if(0){}
}
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
/**
* Reads class constant from string name and returns its value
*/
int phalcon_get_class_constant(zval *return_value, zend_class_entry *ce, char *constant_name, int constant_length TSRMLS_DC){
zval **result_ptr;
if (zend_hash_find(&ce->constants_table, constant_name, constant_length+1, (void **) &result_ptr) != SUCCESS) {
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Undefined class constant '%s::%s'", ce->name, constant_name);
phalcon_memory_restore_stack(TSRMLS_C);
return FAILURE;
} else {
ZVAL_ZVAL(return_value, *result_ptr, 1, 0);
}
return SUCCESS;
}
/**
* Unsets zval index from array
*/
int PHALCON_FASTCALL phalcon_array_unset(zval *arr, zval *index){
zval *copy;
int exists, copied = 0;
if (Z_TYPE_P(arr) != IS_ARRAY) {
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, 1, 0);
convert_to_long(copy);
index = copy;
copied = 1;
}
}
if (Z_TYPE_P(index) == IS_STRING) {
exists = zend_hash_del(Z_ARRVAL_P(arr), Z_STRVAL_P(index), Z_STRLEN_P(index)+1);
} else {
exists = zend_hash_index_del(Z_ARRVAL_P(arr), Z_LVAL_P(index));
}
if (copied) {
zval_ptr_dtor(©);
}
return exists;
}
/**
* Make a bulk save on all attached objects
*
* @return boolean
*/
PHP_METHOD(Phalcon_Transaction, save){
zval *a0 = NULL;
zval *t0 = NULL, *t1 = NULL;
zval *v0 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(a0);
array_init(a0);
phalcon_update_property_zval(this_ptr, "_messages", strlen("_messages"), a0 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_dependencies", sizeof("_dependencies")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
if (Z_TYPE_P(t0) != IS_ARRAY) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid argument supplied for foreach()");
} else {
ah0 = Z_ARRVAL_P(t0);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_815a_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_815a_0;
}
PHALCON_INIT_VAR(v0);
ZVAL_ZVAL(v0, *hd, 1, 0);
PHALCON_INIT_VAR(r0);
PHALCON_CALL_METHOD(r0, v0, "save", PHALCON_CALL_DEFAULT);
PHALCON_INIT_VAR(t1);
ZVAL_BOOL(t1, 0);
PHALCON_INIT_VAR(r1);
is_equal_function(r1, r0, t1 TSRMLS_CC);
if (zend_is_true(r1)) {
PHALCON_INIT_VAR(r2);
PHALCON_CALL_METHOD(r2, v0, "getmessages", PHALCON_CALL_DEFAULT);
phalcon_update_property_zval(this_ptr, "_messages", strlen("_messages"), r2 TSRMLS_CC);
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_815a_0;
fee_815a_0:
if(0){ };
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
/**
* Gets a list of columns
*
* @param array $columnList
* @return string
*/
PHP_METHOD(Phalcon_Db_Dialect_Mysql, getColumnList){
zval *column_list = NULL, *str_list = NULL, *column = NULL;
zval *a0 = NULL;
zval *r0 = NULL, *r1 = NULL;
zval *c0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &column_list) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(str_list, a0);
if (phalcon_valid_foreach(column_list TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(column_list);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_52be_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_52be_0;
}
PHALCON_INIT_VAR(column);
ZVAL_ZVAL(column, *hd, 1, 0);
PHALCON_INIT_VAR(r0);
PHALCON_CONCAT_SVS(r0, "`", column, "`");
phalcon_array_append(&str_list, r0, PHALCON_SEPARATE_PLZ TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_52be_0;
fee_52be_0:
if(0){}
} else {
return;
}
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, ", ", 1);
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_fast_join(r1, c0, str_list TSRMLS_CC);
PHALCON_RETURN_DZVAL(r1);
}
/**
* Gets attached files as Phalcon\Http\Request\File instances
*
* @return Phalcon\Http\Request\File[]
*/
PHP_METHOD(Phalcon_Http_Request, getUploadedFiles){
zval *super_files = NULL, *number_files = NULL, *files = NULL, *file = NULL;
zval *request_file = NULL, *empty_files = NULL;
zval *g0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_get_global(&g0, SL("_FILES")+1 TSRMLS_CC);
PHALCON_CPY_WRT(super_files, g0);
PHALCON_INIT_VAR(number_files);
phalcon_fast_count(number_files, super_files TSRMLS_CC);
if (zend_is_true(number_files)) {
PHALCON_INIT_VAR(files);
array_init(files);
if (!phalcon_valid_foreach(super_files TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(super_files);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_ac06_1:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_ac06_1;
}
PHALCON_INIT_VAR(file);
ZVAL_ZVAL(file, *hd, 1, 0);
PHALCON_INIT_VAR(request_file);
object_init_ex(request_file, phalcon_http_request_file_ce);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(request_file, "__construct", file, PH_CHECK);
phalcon_array_append(&files, request_file, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_ac06_1;
fee_ac06_1:
RETURN_CTOR(files);
}
PHALCON_INIT_VAR(empty_files);
array_init(empty_files);
RETURN_CTOR(empty_files);
}
/**
* Resets the request and internal values to avoid those fields will have any default value
*/
PHP_METHOD(Phalcon_Tag, resetInput){
zval *value = NULL, *key = NULL;
zval *a0 = NULL;
zval *g0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(a0);
array_init(a0);
phalcon_update_static_property(SL("phalcon\\tag"), SL("_displayValues"), a0 TSRMLS_CC);
phalcon_get_global(&g0, SL("_POST")+1 TSRMLS_CC);
if (!phalcon_valid_foreach(g0 TSRMLS_CC)) {
return;
}
ALLOC_HASHTABLE(ah0);
zend_hash_init(ah0, 0, NULL, NULL, 0);
zend_hash_copy(ah0, Z_ARRVAL_P(g0), NULL, NULL, sizeof(zval*));
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_9b93_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_9b93_0;
}
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
phalcon_array_unset(g0, key);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_9b93_0;
fee_9b93_0:
zend_hash_destroy(ah0);
efree(ah0);
PHALCON_MM_RESTORE();
}
/**
* Gets a list of columns
*
* @param array $columnList
* @return string
*/
PHP_METHOD(Phalcon_Db_Dialect_Mysql, getColumnList){
zval *column_list = NULL, *str_list = NULL, *column = NULL, *column_quoted = NULL;
zval *comma = NULL, *joined_list = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &column_list) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(str_list);
array_init(str_list);
if (!phalcon_valid_foreach(column_list TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(column_list);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_52be_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_52be_0;
}
PHALCON_INIT_VAR(column);
ZVAL_ZVAL(column, *hd, 1, 0);
PHALCON_INIT_VAR(column_quoted);
PHALCON_CONCAT_SVS(column_quoted, "`", column, "`");
phalcon_array_append(&str_list, column_quoted, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_52be_0;
fee_52be_0:
PHALCON_INIT_VAR(comma);
ZVAL_STRING(comma, ", ", 1);
PHALCON_INIT_VAR(joined_list);
phalcon_fast_join(joined_list, comma, str_list TSRMLS_CC);
RETURN_CTOR(joined_list);
}
/* {{{ zend_user_it_get_current_key */
ZEND_API void zend_user_it_get_current_key(zend_object_iterator *_iter, zval *key)
{
zend_user_iterator *iter = (zend_user_iterator*)_iter;
zval *object = &iter->it.data;
zval retval;
zend_call_method_with_0_params(object, iter->ce, &iter->ce->iterator_funcs.zf_key, "key", &retval);
if (Z_TYPE(retval) != IS_UNDEF) {
ZVAL_ZVAL(key, &retval, 1, 1);
} else {
if (!EG(exception)) {
zend_error(E_WARNING, "Nothing returned from %s::key()", iter->ce->name->val);
}
ZVAL_LONG(key, 0);
}
}
