PHP_METHOD(PocketMine_Math_Vector2, distance) {
zephir_nts_static zephir_fcall_cache_entry *_4 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *x, *y = NULL, *_0 = NULL, *_1, *_2, *_3 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &x, &y);
if (!y) {
ZEPHIR_INIT_VAR(y);
ZVAL_LONG(y, 0);
}
if (zephir_instance_of_ev(x, pocketmine_math_vector2_ce TSRMLS_CC)) {
ZEPHIR_OBS_VAR(_1);
zephir_read_property(&_1, x, SL("x"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(_2);
zephir_read_property(&_2, x, SL("y"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "distancesquared", NULL, _1, _2);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&_3, "sqrt", &_4, _0);
zephir_check_call_status();
RETURN_MM_DOUBLE(zephir_get_doubleval(_3));
}
ZEPHIR_CALL_METHOD(&_0, this_ptr, "distancesquared", NULL, x, y);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&_3, "sqrt", &_4, _0);
zephir_check_call_status();
RETURN_MM_DOUBLE(zephir_get_doubleval(_3));
}
PHP_METHOD(Test_Oo_PropertyAccess, __construct) {
zval *test, *test1, *_0, *_1, *_2, *_3, *_4, *_5, *_6, *_7 = NULL, *_8, *_9;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(test);
object_init(test);
ZEPHIR_INIT_VAR(_0);
array_init_size(_0, 6);
ZEPHIR_INIT_VAR(_1);
ZVAL_LONG(_1, 1);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 2);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 3);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 5);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_DOUBLE(_1, 6.00);
zephir_array_fast_append(_0, _1);
zephir_update_property_zval(test, SL("test"), _0 TSRMLS_CC);
ZEPHIR_OBS_VAR(_2);
zephir_read_property(&_2, test, SL("test"), PH_NOISY_CC);
zephir_array_fetch_long(&_3, _2, 0, PH_NOISY | PH_READONLY TSRMLS_CC);
zephir_update_property_zval(test, SL("test2"), _3 TSRMLS_CC);
ZEPHIR_OBS_VAR(_4);
zephir_read_property(&_4, test, SL("test"), PH_NOISY_CC);
zephir_array_fetch_long(&_5, _4, 1, PH_NOISY | PH_READONLY TSRMLS_CC);
zephir_update_property_zval(test, SL("test3"), _5 TSRMLS_CC);
ZEPHIR_INIT_BNVAR(_1);
array_init_size(_1, 5);
ZEPHIR_OBS_VAR(_6);
zephir_read_property(&_6, test, SL("test"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(_7);
zephir_array_fetch_long(&_7, _6, 1, PH_NOISY TSRMLS_CC);
zephir_array_fast_append(_1, _7);
ZEPHIR_INIT_VAR(_8);
ZVAL_LONG(_8, 1);
zephir_array_fast_append(_1, _8);
ZEPHIR_INIT_BNVAR(_8);
ZVAL_LONG(_8, 2);
zephir_array_fast_append(_1, _8);
ZEPHIR_INIT_BNVAR(_8);
ZVAL_LONG(_8, 3);
zephir_array_fast_append(_1, _8);
zephir_update_property_zval(test, SL("test3"), _1 TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("a"), test TSRMLS_CC);
_9 = zephir_fetch_nproperty_this(this_ptr, SL("a"), PH_NOISY_CC);
ZEPHIR_OBS_NVAR(_7);
zephir_read_property(&_7, _9, SL("test2"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("b"), _7 TSRMLS_CC);
test1 = zephir_fetch_nproperty_this(this_ptr, SL("a"), PH_NOISY_CC);
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Test_Trie, getTrieNodeByKey) {
zend_class_entry *_5;
zephir_nts_static zephir_fcall_cache_entry *_2 = NULL;
int i, ZEPHIR_LAST_CALL_STATUS;
zend_bool create;
zval *key_param = NULL, *create_param = NULL, *trieNode = NULL, *keyLen, *character = NULL, _0 = zval_used_for_init, _1 = zval_used_for_init, *_3 = NULL, *_4 = NULL, *_6 = NULL, *_7;
zval *key = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &key_param, &create_param);
zephir_get_strval(key, key_param);
if (!create_param) {
create = 0;
} else {
create = zephir_get_boolval(create_param);
}
ZEPHIR_OBS_VAR(trieNode);
zephir_read_property_this(&trieNode, this_ptr, SL("trie"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(keyLen);
ZVAL_LONG(keyLen, zephir_fast_strlen_ev(key));
i = 0;
while (1) {
if (!(ZEPHIR_GT_LONG(keyLen, i))) {
break;
}
ZEPHIR_SINIT_NVAR(_0);
ZVAL_LONG(&_0, i);
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, 1);
ZEPHIR_CALL_FUNCTION(&character, "substr", &_2, key, &_0, &_1);
zephir_check_call_status();
ZEPHIR_OBS_NVAR(_3);
zephir_read_property(&_3, trieNode, SL("children"), PH_NOISY_CC);
if (!(zephir_array_isset(_3, character))) {
if (create) {
ZEPHIR_INIT_LNVAR(_4);
_5 = zend_fetch_class(SL("tries\\trienode"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
object_init_ex(_4, _5);
if (zephir_has_constructor(_4 TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, _4, "__construct", NULL);
zephir_check_call_status();
}
zephir_update_property_array(trieNode, SL("children"), character, _4 TSRMLS_CC);
} else {
RETURN_MM_BOOL(0);
}
}
ZEPHIR_OBS_NVAR(_6);
zephir_read_property(&_6, trieNode, SL("children"), PH_NOISY_CC);
zephir_array_fetch(&_7, _6, character, PH_NOISY | PH_READONLY TSRMLS_CC);
ZEPHIR_CPY_WRT(trieNode, _7);
i += 1;
}
RETURN_CCTOR(trieNode);
}
/**
* @inheritdoc
*/
PHP_METHOD(Owl_Log_Formatter_Json, format) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_2 = NULL;
zval *_0;
zval *record, *_1 = NULL, *_3, *_4 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &record);
ZEPHIR_INIT_VAR(_0);
zephir_create_array(_0, 3, 0 TSRMLS_CC);
ZEPHIR_OBS_VAR(_3);
zephir_read_property(&_3, record, SL("level"), PH_NOISY_CC);
ZEPHIR_CALL_CE_STATIC(&_1, owl_log_logger_ce, "getleveltitle", &_2, 18, _3);
zephir_check_call_status();
zephir_array_update_string(&_0, SL("type"), &_1, PH_COPY | PH_SEPARATE);
ZEPHIR_OBS_VAR(_4);
zephir_read_property(&_4, record, SL("message"), PH_NOISY_CC);
zephir_array_update_string(&_0, SL("message"), &_4, PH_COPY | PH_SEPARATE);
ZEPHIR_OBS_NVAR(_4);
zephir_read_property(&_4, record, SL("timestamp"), PH_NOISY_CC);
zephir_array_update_string(&_0, SL("timestamp"), &_4, PH_COPY | PH_SEPARATE);
zephir_json_encode(return_value, &(return_value), _0, 0 TSRMLS_CC);
RETURN_MM();
}
PHP_METHOD(PocketMine_Math_Vector2, subtract) {
int ZEPHIR_LAST_CALL_STATUS;
zval *x, *y = NULL, *_0 = NULL, *_1, *_2;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &x, &y);
if (!y) {
ZEPHIR_INIT_VAR(y);
ZVAL_LONG(y, 0);
}
if (zephir_instance_of_ev(x, pocketmine_math_vector2_ce TSRMLS_CC)) {
ZEPHIR_OBS_VAR(_1);
zephir_read_property(&_1, x, SL("x"), PH_NOISY_CC);
zephir_negate(_1 TSRMLS_CC);
ZEPHIR_OBS_VAR(_2);
zephir_read_property(&_2, x, SL("y"), PH_NOISY_CC);
zephir_negate(_2 TSRMLS_CC);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "add", NULL, _1, _2);
zephir_check_call_status();
RETURN_CCTOR(_0);
}
zephir_negate(x TSRMLS_CC);
zephir_negate(y TSRMLS_CC);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "add", NULL, x, y);
zephir_check_call_status();
RETURN_CCTOR(_0);
}
PHP_METHOD(Phalcon_Session_Adapter_Libmemcached, write) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *id, id_sub, *data, data_sub, name, _0, _1;
zval *this_ptr = getThis();
ZVAL_UNDEF(&id_sub);
ZVAL_UNDEF(&data_sub);
ZVAL_UNDEF(&name);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &id, &data);
ZEPHIR_CALL_METHOD(&name, this_ptr, "getprefixedname", NULL, 0, id);
zephir_check_call_status();
zephir_read_property(&_0, this_ptr, SL("connection"), PH_NOISY_CC | PH_READONLY);
zephir_read_property(&_1, this_ptr, SL("ttl"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_RETURN_CALL_METHOD(&_0, "save", NULL, 0, &name, data, &_1);
zephir_check_call_status();
RETURN_MM();
}
PHP_METHOD(PocketMine_Math_Vector2, add) {
int ZEPHIR_LAST_CALL_STATUS;
zval *x, *y = NULL, *_0 = NULL, *_1, *_2, *_3, *_4, *_5;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &x, &y);
if (!y) {
ZEPHIR_INIT_VAR(y);
ZVAL_LONG(y, 0);
}
if (zephir_instance_of_ev(x, pocketmine_math_vector2_ce TSRMLS_CC)) {
ZEPHIR_OBS_VAR(_1);
zephir_read_property(&_1, x, SL("x"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(_2);
zephir_read_property(&_2, x, SL("y"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "add", NULL, _1, _2);
zephir_check_call_status();
RETURN_CCTOR(_0);
}
object_init_ex(return_value, pocketmine_math_vector2_ce);
_3 = zephir_fetch_nproperty_this(this_ptr, SL("x"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_4);
zephir_add_function(_4, _3, x TSRMLS_CC);
_3 = zephir_fetch_nproperty_this(this_ptr, SL("y"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_5);
zephir_add_function(_5, _3, y TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, _4, _5);
zephir_check_call_status();
RETURN_MM();
}
/**
* Destroys the session bag
*
*<code>
* $user->destroy();
*</code>
*/
PHP_METHOD(Phalcon_Session_Bag, destroy) {
zval _0, _1, _2, _3;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *this_ptr = getThis();
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1);
ZVAL_UNDEF(&_2);
ZVAL_UNDEF(&_3);
ZEPHIR_MM_GROW();
zephir_read_property(&_0, this_ptr, SL("_initialized"), PH_NOISY_CC | PH_READONLY);
if (ZEPHIR_IS_FALSE_IDENTICAL(&_0)) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "initialize", NULL, 0);
zephir_check_call_status();
}
ZEPHIR_INIT_VAR(&_1);
array_init(&_1);
zephir_update_property_zval(this_ptr, SL("_data"), &_1);
zephir_read_property(&_2, this_ptr, SL("_session"), PH_NOISY_CC | PH_READONLY);
zephir_read_property(&_3, this_ptr, SL("_name"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_CALL_METHOD(NULL, &_2, "remove", NULL, 0, &_3);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Check whether a property is defined in the internal bag
*
*<code>
* var_dump(
* $user->has("name")
* );
*</code>
*/
PHP_METHOD(Phalcon_Session_Bag, has) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *property_param = NULL, _0, _1;
zval property;
zval *this_ptr = getThis();
ZVAL_UNDEF(&property);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &property_param);
if (UNEXPECTED(Z_TYPE_P(property_param) != IS_STRING && Z_TYPE_P(property_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'property' must be of the type string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(property_param) == IS_STRING)) {
zephir_get_strval(&property, property_param);
} else {
ZEPHIR_INIT_VAR(&property);
ZVAL_EMPTY_STRING(&property);
}
zephir_read_property(&_0, this_ptr, SL("_initialized"), PH_NOISY_CC | PH_READONLY);
if (ZEPHIR_IS_FALSE_IDENTICAL(&_0)) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "initialize", NULL, 0);
zephir_check_call_status();
}
zephir_read_property(&_1, this_ptr, SL("_data"), PH_NOISY_CC | PH_READONLY);
RETURN_MM_BOOL(zephir_array_isset(&_1, &property));
}
/**
* Returns a cached content
*/
PHP_METHOD(Phalcon_Cache_Backend_Libmemcached, get) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *keyName_param = NULL, *lifetime = NULL, lifetime_sub, __$null, memcache, prefixedKey, cachedContent, _0, _1, _2;
zval keyName;
zval *this_ptr = getThis();
ZVAL_UNDEF(&keyName);
ZVAL_UNDEF(&lifetime_sub);
ZVAL_NULL(&__$null);
ZVAL_UNDEF(&memcache);
ZVAL_UNDEF(&prefixedKey);
ZVAL_UNDEF(&cachedContent);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1);
ZVAL_UNDEF(&_2);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &keyName_param, &lifetime);
zephir_get_strval(&keyName, keyName_param);
if (!lifetime) {
lifetime = &lifetime_sub;
lifetime = &__$null;
}
ZEPHIR_OBS_VAR(&memcache);
zephir_read_property(&memcache, this_ptr, SL("_memcache"), PH_NOISY_CC);
if (Z_TYPE_P(&memcache) != IS_OBJECT) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_connect", NULL, 0);
zephir_check_call_status();
ZEPHIR_OBS_NVAR(&memcache);
zephir_read_property(&memcache, this_ptr, SL("_memcache"), PH_NOISY_CC);
}
zephir_read_property(&_0, this_ptr, SL("_prefix"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_INIT_VAR(&prefixedKey);
ZEPHIR_CONCAT_VV(&prefixedKey, &_0, &keyName);
zephir_update_property_zval(this_ptr, SL("_lastKey"), &prefixedKey);
ZEPHIR_CALL_METHOD(&cachedContent, &memcache, "get", NULL, 0, &prefixedKey);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_1, &memcache, "getresultcode", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_LONG_IDENTICAL(&_1, 16)) {
RETURN_MM_NULL();
}
if (zephir_is_numeric(&cachedContent)) {
RETURN_CCTOR(&cachedContent);
}
zephir_read_property(&_2, this_ptr, SL("_frontend"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_RETURN_CALL_METHOD(&_2, "afterretrieve", NULL, 0, &cachedContent);
zephir_check_call_status();
RETURN_MM();
}
/**
* Initializes the session bag. This method must not be called directly, the
* class calls it when its internal data is accessed
*/
PHP_METHOD(Phalcon_Session_Bag, initialize) {
zval __$true, __$false, session, dependencyInjector, data, _2, _1$$3;
zend_long ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_0 = NULL;
zval *this_ptr = getThis();
ZVAL_BOOL(&__$true, 1);
ZVAL_BOOL(&__$false, 0);
ZVAL_UNDEF(&session);
ZVAL_UNDEF(&dependencyInjector);
ZVAL_UNDEF(&data);
ZVAL_UNDEF(&_2);
ZVAL_UNDEF(&_1$$3);
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(&session);
zephir_read_property(&session, this_ptr, SL("_session"), PH_NOISY_CC);
if (Z_TYPE_P(&session) != IS_OBJECT) {
ZEPHIR_OBS_VAR(&dependencyInjector);
zephir_read_property(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(&dependencyInjector) != IS_OBJECT) {
ZEPHIR_CALL_CE_STATIC(&dependencyInjector, phalcon_di_ce, "getdefault", &_0, 0);
zephir_check_call_status();
if (Z_TYPE_P(&dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_session_exception_ce, "A dependency injection object is required to access the 'session' service", "phalcon/session/bag.zep", 212);
return;
}
}
ZEPHIR_INIT_VAR(&_1$$3);
ZVAL_STRING(&_1$$3, "session");
ZEPHIR_CALL_METHOD(&session, &dependencyInjector, "getshared", NULL, 0, &_1$$3);
zephir_check_call_status();
zephir_update_property_zval(this_ptr, SL("_session"), &session);
}
zephir_read_property(&_2, this_ptr, SL("_name"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_CALL_METHOD(&data, &session, "get", NULL, 0, &_2);
zephir_check_call_status();
if (Z_TYPE_P(&data) != IS_ARRAY) {
ZEPHIR_INIT_NVAR(&data);
array_init(&data);
}
zephir_update_property_zval(this_ptr, SL("_data"), &data);
if (1) {
zephir_update_property_zval(this_ptr, SL("_initialized"), &__$true);
} else {
zephir_update_property_zval(this_ptr, SL("_initialized"), &__$false);
}
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Owl_Router_Router, match) {
zend_bool _5, _7;
int ZEPHIR_LAST_CALL_STATUS;
HashTable *_2;
HashPosition _1;
zval *uri_param = NULL, *method_param = NULL, *router = NULL, *_0, **_3, *_4 = NULL, *_6 = NULL, *_8 = NULL;
zval *uri = NULL, *method = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &uri_param, &method_param);
zephir_get_strval(uri, uri_param);
if (!method_param) {
ZEPHIR_INIT_VAR(method);
ZVAL_STRING(method, "GET", 1);
} else {
zephir_get_strval(method, method_param);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("routers"), PH_NOISY_CC);
zephir_is_iterable(_0, &_2, &_1, 0, 0, "owl/Router/Router.zep", 56);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HVALUE(router, _3);
ZEPHIR_CALL_METHOD(&_4, router, "match", NULL, 0, uri);
zephir_check_call_status();
_5 = zephir_is_true(_4);
if (_5) {
ZEPHIR_OBS_NVAR(_6);
zephir_read_property(&_6, router, SL("method"), PH_NOISY_CC);
_7 = ZEPHIR_IS_LONG(_6, 7);
if (!(_7)) {
ZEPHIR_OBS_NVAR(_8);
zephir_read_property(&_8, router, SL("method"), PH_NOISY_CC);
_7 = ZEPHIR_IS_EQUAL(_8, method);
}
_5 = _7;
}
if (_5) {
RETURN_CCTOR(router);
}
}
RETURN_MM_BOOL(0);
}
PHP_METHOD(Dgafka_BookStore_Business_Service_Handler_BookQueryHandler, handleGetByIdQuery) {
int ZEPHIR_LAST_CALL_STATUS;
zval *query, *book = NULL, *_0, *_1, *_2, *_3 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &query);
if (!(zephir_instance_of_ev(query, dgafka_bookstore_business_service_dto_query_book_getbyidquery_ce TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "Parameter 'query' must be an instance of 'Dgafka\\BookStore\\Business\\Service\\Dto\\Query\\Book\\GetByIdQuery'", "", 0);
return;
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("repository"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(_1);
zephir_read_property(&_1, query, SL("id"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&book, _0, "findbyid", NULL, _1);
zephir_check_call_status();
if (!(zephir_instance_of_ev(book, dgafka_bookstore_business_model_entity_book_ce TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(dgafka_bookstore_business_service_handler_exception_notfoundexception_ce, "Results not found.", "dgafka/bookStore/business/service/handler/BookQueryHandler.zep", 45);
return;
}
_2 = zephir_fetch_nproperty_this(this_ptr, SL("converter"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&_3, _2, "convert", NULL, book);
zephir_check_call_status();
ZEPHIR_CPY_WRT(book, _3);
RETURN_CCTOR(book);
}
PHP_METHOD(Test_Issues, someMethod) {
int ZEPHIR_LAST_CALL_STATUS;
zval *methodName, methodName_sub, _0;
zval this_zv;
zval *this_ptr = getThis();
if (EXPECTED(this_ptr)) {
ZVAL_OBJ(&this_zv, Z_OBJ_P(this_ptr));
this_ptr = &this_zv;
} else this_ptr = NULL;
ZVAL_UNDEF(&methodName_sub);
ZVAL_UNDEF(&_0);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &methodName);
zephir_read_property(&_0, this_ptr, SL("adapter"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_RETURN_CALL_METHOD_ZVAL(&_0, methodName, NULL, 0);
zephir_check_call_status();
RETURN_MM();
}
/**
* Filter records by levels
*/
PHP_METHOD(Owl_Log_AbstractWriter, filterRecords) {
HashTable *_2;
HashPosition _1;
zval *records_param = NULL, *index = NULL, *record = NULL, *_0, **_3, *_4 = NULL, *_5;
zval *records = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &records_param);
zephir_get_arrval(records, records_param);
ZEPHIR_OBS_VAR(_0);
zephir_read_property_this(&_0, this_ptr, SL("levels"), PH_NOISY_CC);
if (ZEPHIR_IS_EMPTY(_0)) {
RETURN_CTOR(records);
}
zephir_is_iterable(records, &_2, &_1, 1, 0, "owl/Log/AbstractWriter.zep", 125);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HMKEY(index, _2, _1);
ZEPHIR_GET_HVALUE(record, _3);
ZEPHIR_OBS_NVAR(_4);
zephir_read_property(&_4, record, SL("level"), PH_NOISY_CC);
_5 = zephir_fetch_nproperty_this(this_ptr, SL("levels"), PH_NOISY_CC);
if (!(zephir_fast_in_array(_4, _5 TSRMLS_CC))) {
zephir_array_unset(&records, index, PH_SEPARATE);
}
}
RETURN_CTOR(records);
}
/**
* Returns a parameter in a specific position
*
* @return array
*/
PHP_METHOD(Phalcon_Di_Service, getParameter) {
zval *position_param = NULL, definition, arguments, parameter;
zend_long position;
zval *this_ptr = getThis();
ZVAL_UNDEF(&definition);
ZVAL_UNDEF(&arguments);
ZVAL_UNDEF(¶meter);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &position_param);
position = zephir_get_intval(position_param);
ZEPHIR_OBS_VAR(&definition);
zephir_read_property(&definition, this_ptr, SL("_definition"), PH_NOISY_CC);
if (Z_TYPE_P(&definition) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_di_exception_ce, "Definition must be an array to obtain its parameters", "phalcon/di/service.zep", 246);
return;
}
if (zephir_array_isset_string_fetch(&arguments, &definition, SL("arguments"), 1)) {
if (zephir_array_isset_long_fetch(¶meter, &arguments, position, 1 TSRMLS_CC)) {
RETURN_CTOR(¶meter);
}
}
RETURN_MM_NULL();
}
/**
* Return the strategy to obtain the meta-data
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, getStrategy) {
zval _0, _1$$3;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *this_ptr = getThis();
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1$$3);
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(&_0);
zephir_read_property(&_0, this_ptr, SL("_strategy"), PH_NOISY_CC);
if (Z_TYPE_P(&_0) == IS_NULL) {
ZEPHIR_INIT_VAR(&_1$$3);
object_init_ex(&_1$$3, phalcon_mvc_model_metadata_strategy_introspection_ce);
if (zephir_has_constructor(&_1$$3 TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 0);
zephir_check_call_status();
}
zephir_update_property_zval(this_ptr, SL("_strategy"), &_1$$3);
}
RETURN_MM_MEMBER(getThis(), "_strategy");
}
/**
* Unsets an index in an array property
*/
int zephir_unset_property_array(zval *object, char *property, unsigned int property_length, zval *index)
{
zval tmp;
int separated = 0;
if (Z_TYPE_P(object) == IS_OBJECT) {
zephir_read_property(&tmp, object, property, property_length, PH_NOISY_CC);
Z_TRY_DELREF(tmp);
/** Separation only when refcount > 1 */
if (Z_REFCOUNTED(tmp) && Z_REFCOUNT(tmp) > 1) {
if (!Z_ISREF(tmp)) {
zval new_zv;
ZVAL_DUP(&new_zv, &tmp);
ZVAL_COPY_VALUE(&tmp, &new_zv);
Z_TRY_DELREF(new_zv);
separated = 1;
}
}
zephir_array_unset(&tmp, index, PH_SEPARATE);
if (separated) {
zephir_update_property_zval(object, property, property_length, &tmp);
}
}
return SUCCESS;
}
/**
* Returns a form by its name
*/
PHP_METHOD(Phalcon_Forms_Manager, get) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *name_param = NULL, form, _0, _1$$3;
zval name, _2$$3;
zval *this_ptr = getThis();
ZVAL_UNDEF(&name);
ZVAL_UNDEF(&_2$$3);
ZVAL_UNDEF(&form);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1$$3);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &name_param);
zephir_get_strval(&name, name_param);
ZEPHIR_OBS_VAR(&form);
zephir_read_property(&_0, this_ptr, SL("_forms"), PH_NOISY_CC | PH_READONLY);
if (!(zephir_array_isset_fetch(&form, &_0, &name, 0 TSRMLS_CC))) {
ZEPHIR_INIT_VAR(&_1$$3);
object_init_ex(&_1$$3, phalcon_forms_exception_ce);
ZEPHIR_INIT_VAR(&_2$$3);
ZEPHIR_CONCAT_SVS(&_2$$3, "There is no form with name='", &name, "'");
ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 4, &_2$$3);
zephir_check_call_status();
zephir_throw_exception_debug(&_1$$3, "phalcon/forms/manager.zep", 43 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
RETURN_CCTOR(&form);
}
/**
* Returns an option by the specified name
* If the option doesn't exist null is returned
*/
PHP_METHOD(Phalcon_Mvc_Model_Relation, getOption) {
zval *name_param = NULL, option, _0;
zval name;
zval *this_ptr = getThis();
ZVAL_UNDEF(&name);
ZVAL_UNDEF(&option);
ZVAL_UNDEF(&_0);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &name_param);
if (UNEXPECTED(Z_TYPE_P(name_param) != IS_STRING && Z_TYPE_P(name_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'name' must be of the type string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(name_param) == IS_STRING)) {
zephir_get_strval(&name, name_param);
} else {
ZEPHIR_INIT_VAR(&name);
ZVAL_EMPTY_STRING(&name);
}
zephir_read_property(&_0, this_ptr, SL("_options"), PH_NOISY_CC | PH_READONLY);
if (zephir_array_isset_fetch(&option, &_0, &name, 1 TSRMLS_CC)) {
RETURN_CTOR(&option);
}
RETURN_MM_NULL();
}
/**
* Returns the paths using positions as keys and names as values
*
* @return array
*/
PHP_METHOD(Test_Router_Route, getReversedPaths) {
zend_string *_3;
zend_ulong _2;
zval reversed, path, position, _0, *_1;
ZEPHIR_INIT_THIS();
ZVAL_UNDEF(&reversed);
ZVAL_UNDEF(&path);
ZVAL_UNDEF(&position);
ZVAL_UNDEF(&_0);
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(&reversed);
array_init(&reversed);
zephir_read_property(&_0, this_ptr, SL("_paths"), PH_NOISY_CC | PH_READONLY);
zephir_is_iterable(&_0, 0, "test/router/route.zep", 478);
ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_0), _2, _3, _1)
{
ZEPHIR_INIT_NVAR(&path);
if (_3 != NULL) {
ZVAL_STR_COPY(&path, _3);
} else {
ZVAL_LONG(&path, _2);
}
ZEPHIR_INIT_NVAR(&position);
ZVAL_COPY(&position, _1);
zephir_array_update_zval(&reversed, &position, &path, PH_COPY | PH_SEPARATE);
} ZEND_HASH_FOREACH_END();
/**
* Generates a local path
*/
PHP_METHOD(Phalcon_Mvc_Url, path) {
zval *path_param = NULL, _0;
zval path;
zval *this_ptr = getThis();
ZVAL_UNDEF(&path);
ZVAL_UNDEF(&_0);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &path_param);
if (!path_param) {
ZEPHIR_INIT_VAR(&path);
ZVAL_STRING(&path, "");
} else {
zephir_get_strval(&path, path_param);
}
zephir_read_property(&_0, this_ptr, SL("basePath"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_CONCAT_VV(return_value, &_0, &path);
RETURN_MM();
}
/**
* Sets a prefix for all the URIs to be generated
*
*<code>
* $url->setBaseUri("/invo/");
*
* $url->setBaseUri("/invo/index.php/");
*</code>
*/
PHP_METHOD(Phalcon_Mvc_Url, setBaseUri) {
zval *baseUri_param = NULL, _0;
zval baseUri;
zval *this_ptr = getThis();
ZVAL_UNDEF(&baseUri);
ZVAL_UNDEF(&_0);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &baseUri_param);
if (UNEXPECTED(Z_TYPE_P(baseUri_param) != IS_STRING && Z_TYPE_P(baseUri_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'baseUri' must be of the type string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(baseUri_param) == IS_STRING)) {
zephir_get_strval(&baseUri, baseUri_param);
} else {
ZEPHIR_INIT_VAR(&baseUri);
ZVAL_EMPTY_STRING(&baseUri);
}
zephir_update_property_zval(this_ptr, SL("baseUri"), &baseUri);
zephir_read_property(&_0, this_ptr, SL("staticBaseUri"), PH_NOISY_CC | PH_READONLY);
if (Z_TYPE_P(&_0) == IS_NULL) {
zephir_update_property_zval(this_ptr, SL("staticBaseUri"), &baseUri);
}
RETURN_THIS();
}
/**
* Returns the prefix for all the generated urls. By default /
*/
PHP_METHOD(Phalcon_Mvc_Url, getBaseUri) {
zval *_SERVER, baseUri, phpSelf, uri, _0;
zval *this_ptr = getThis();
ZVAL_UNDEF(&baseUri);
ZVAL_UNDEF(&phpSelf);
ZVAL_UNDEF(&uri);
ZVAL_UNDEF(&_0);
ZEPHIR_MM_GROW();
zephir_get_global(&_SERVER, SL("_SERVER"));
zephir_read_property(&_0, this_ptr, SL("baseUri"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_CPY_WRT(&baseUri, &_0);
if (Z_TYPE_P(&baseUri) == IS_NULL) {
ZEPHIR_OBS_VAR(&phpSelf);
if (zephir_array_isset_string_fetch(&phpSelf, _SERVER, SL("PHP_SELF"), 0)) {
ZEPHIR_INIT_VAR(&uri);
phalcon_get_uri(&uri, &phpSelf);
} else {
ZEPHIR_INIT_NVAR(&uri);
ZVAL_NULL(&uri);
}
ZEPHIR_INIT_NVAR(&baseUri);
if (!(zephir_is_true(&uri))) {
ZVAL_STRING(&baseUri, "/");
} else {
ZEPHIR_CONCAT_SVS(&baseUri, "/", &uri, "/");
}
zephir_update_property_zval(this_ptr, SL("baseUri"), &baseUri);
}
RETURN_CCTOR(&baseUri);
}
PHP_METHOD(Dgafka_BookStore_Business_Service_Handler_BookQueryHandler, handleGetByQuery) {
HashTable *_4;
HashPosition _3;
int ZEPHIR_LAST_CALL_STATUS;
zval *query, *bookCollection = NULL, *book = NULL, *bookResults, *_0, *_1, *_2, **_5, *_6, *_7 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &query);
if (!(zephir_instance_of_ev(query, dgafka_bookstore_business_service_dto_query_book_getbyquery_ce TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "Parameter 'query' must be an instance of 'Dgafka\\BookStore\\Business\\Service\\Dto\\Query\\Book\\GetByQuery'", "", 0);
return;
}
ZEPHIR_INIT_VAR(bookResults);
array_init(bookResults);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("repository"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(_1);
zephir_read_property(&_1, query, SL("orderBy"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(_2);
zephir_read_property(&_2, query, SL("type"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&bookCollection, _0, "findby", NULL, _1, _2);
zephir_check_call_status();
if (ZEPHIR_IS_EMPTY(bookCollection)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(dgafka_bookstore_business_service_handler_exception_notfoundexception_ce, "Results not found.", "dgafka/bookStore/business/service/handler/BookQueryHandler.zep", 27);
return;
}
zephir_is_iterable(bookCollection, &_4, &_3, 0, 0, "dgafka/bookStore/business/service/handler/BookQueryHandler.zep", 34);
for (
; zephir_hash_get_current_data_ex(_4, (void**) &_5, &_3) == SUCCESS
; zephir_hash_move_forward_ex(_4, &_3)
) {
ZEPHIR_GET_HVALUE(book, _5);
_6 = zephir_fetch_nproperty_this(this_ptr, SL("converter"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&_7, _6, "convert", NULL, book);
zephir_check_call_status();
zephir_array_append(&bookResults, _7, PH_SEPARATE, "dgafka/bookStore/business/service/handler/BookQueryHandler.zep", 31);
}
ZEPHIR_INIT_NVAR(bookCollection);
object_init_ex(bookCollection, dgafka_bookstore_business_service_dto_bookcollection_ce);
ZEPHIR_CALL_METHOD(NULL, bookCollection, "__construct", NULL, bookResults);
zephir_check_call_status();
RETURN_CCTOR(bookCollection);
}
PHP_METHOD(PocketMine_Math_Vector2, distanceSquared) {
zephir_nts_static zephir_fcall_cache_entry *_5 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *x, *y = NULL, *_0 = NULL, *_1 = NULL, *_2 = NULL, _3 = zval_used_for_init, _4 = zval_used_for_init, *_6 = NULL, *_7;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &x, &y);
if (!y) {
ZEPHIR_INIT_VAR(y);
ZVAL_LONG(y, 0);
}
if (zephir_instance_of_ev(x, pocketmine_math_vector2_ce TSRMLS_CC)) {
ZEPHIR_OBS_VAR(_1);
zephir_read_property(&_1, x, SL("x"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(_2);
zephir_read_property(&_2, x, SL("y"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "distancesquared", NULL, _1, _2);
zephir_check_call_status();
RETURN_MM_DOUBLE(zephir_get_doubleval(_0));
}
ZEPHIR_OBS_NVAR(_1);
zephir_read_property_this(&_1, this_ptr, SL("x"), PH_NOISY_CC);
ZEPHIR_SINIT_VAR(_3);
ZVAL_DOUBLE(&_3, (zephir_get_doubleval(_1) - zephir_get_doubleval(x)));
ZEPHIR_SINIT_VAR(_4);
ZVAL_LONG(&_4, 2);
ZEPHIR_CALL_FUNCTION(&_0, "pow", &_5, &_3, &_4);
zephir_check_call_status();
ZEPHIR_OBS_NVAR(_2);
zephir_read_property_this(&_2, this_ptr, SL("y"), PH_NOISY_CC);
ZEPHIR_SINIT_NVAR(_3);
ZVAL_DOUBLE(&_3, (zephir_get_doubleval(_2) - zephir_get_doubleval(y)));
ZEPHIR_SINIT_NVAR(_4);
ZVAL_LONG(&_4, 2);
ZEPHIR_CALL_FUNCTION(&_6, "pow", &_5, &_3, &_4);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_7);
zephir_add_function(_7, _0, _6 TSRMLS_CC);
RETURN_MM_DOUBLE(zephir_get_doubleval(_7));
}
/**
* Applies a format to a message before sent it to the internal log
*
* @param <Item> item
*
* @return string
*/
PHP_METHOD(Phalcon_Logger_Formatter_Json, format) {
zval _4;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *item, item_sub, message, _0, _3, _5, _6, _7, _8, _1$$3, _2$$3;
zval *this_ptr = getThis();
ZVAL_UNDEF(&item_sub);
ZVAL_UNDEF(&message);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_3);
ZVAL_UNDEF(&_5);
ZVAL_UNDEF(&_6);
ZVAL_UNDEF(&_7);
ZVAL_UNDEF(&_8);
ZVAL_UNDEF(&_1$$3);
ZVAL_UNDEF(&_2$$3);
ZVAL_UNDEF(&_4);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &item);
ZEPHIR_CALL_METHOD(&_0, item, "getcontext", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(&_0) == IS_ARRAY) {
ZEPHIR_CALL_METHOD(&_1$$3, item, "getmessage", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_2$$3, item, "getcontext", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&message, this_ptr, "interpolate", NULL, 0, &_1$$3, &_2$$3);
zephir_check_call_status();
} else {
ZEPHIR_CALL_METHOD(&message, item, "getmessage", NULL, 0);
zephir_check_call_status();
}
ZEPHIR_INIT_VAR(&_3);
ZEPHIR_INIT_VAR(&_4);
zephir_create_array(&_4, 3, 0 TSRMLS_CC);
ZEPHIR_CALL_METHOD(&_5, item, "getname", NULL, 0);
zephir_check_call_status();
zephir_array_update_string(&_4, SL("type"), &_5, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_4, SL("message"), &message, PH_COPY | PH_SEPARATE);
zephir_read_property(&_6, this_ptr, SL("dateFormat"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_CALL_METHOD(&_5, item, "gettime", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&_7, "date", NULL, 294, &_6, &_5);
zephir_check_call_status();
zephir_array_update_string(&_4, SL("timestamp"), &_7, PH_COPY | PH_SEPARATE);
zephir_json_encode(&_3, &_4, 0 );
ZEPHIR_INIT_VAR(&_8);
ZEPHIR_GET_CONSTANT(&_8, "PHP_EOL");
ZEPHIR_CONCAT_VV(return_value, &_3, &_8);
RETURN_MM();
}
/**
* Reads meta-data for certain model
*
*<code>
* print_r(
* $metaData->readMetaDataIndex(
* new Robots(),
* 0
* )
* );
*</code>
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, readMetaDataIndex) {
zend_long index, ZEPHIR_LAST_CALL_STATUS;
zval *model, model_sub, *index_param = NULL, source, schema, key, _0, _1, _2, _3, _4, _5;
zval *this_ptr = getThis();
ZVAL_UNDEF(&model_sub);
ZVAL_UNDEF(&source);
ZVAL_UNDEF(&schema);
ZVAL_UNDEF(&key);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1);
ZVAL_UNDEF(&_2);
ZVAL_UNDEF(&_3);
ZVAL_UNDEF(&_4);
ZVAL_UNDEF(&_5);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &model, &index_param);
index = zephir_get_intval(index_param);
ZEPHIR_CALL_METHOD(&source, model, "getsource", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&schema, model, "getschema", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&_0);
zephir_get_class(&_0, model, 1 TSRMLS_CC);
ZEPHIR_INIT_VAR(&key);
ZEPHIR_CONCAT_VSVV(&key, &_0, "-", &schema, &source);
zephir_read_property(&_1, this_ptr, SL("_metaData"), PH_NOISY_CC | PH_READONLY);
zephir_array_fetch(&_2, &_1, &key, PH_READONLY, "phalcon/mvc/model/metadata.zep", 272 TSRMLS_CC);
if (!(zephir_array_isset_long(&_2, index))) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_initialize", NULL, 5, model, &key, &source, &schema);
zephir_check_call_status();
}
zephir_read_property(&_3, this_ptr, SL("_metaData"), PH_NOISY_CC | PH_READONLY);
zephir_array_fetch(&_4, &_3, &key, PH_NOISY | PH_READONLY, "phalcon/mvc/model/metadata.zep", 276 TSRMLS_CC);
zephir_array_fetch_long(&_5, &_4, index, PH_NOISY | PH_READONLY, "phalcon/mvc/model/metadata.zep", 276 TSRMLS_CC);
RETURN_CTOR(&_5);
}
/**
* Increments an object property
*/
int zephir_property_incr_decr(zval *object, char *property_name, unsigned int property_length, unsigned int increment)
{
zval tmp;
zend_class_entry *ce;
int separated = 0;
ZVAL_UNDEF(&tmp);
if (Z_TYPE_P(object) != IS_OBJECT) {
php_error_docref(NULL, E_WARNING, "Attempt to assign property of non-object");
return FAILURE;
}
ce = Z_OBJCE_P(object);
if (ce->parent) {
ce = zephir_lookup_class_ce(ce, property_name, property_length);
}
zephir_read_property(&tmp, object, property_name, property_length, 0);
if (Z_TYPE(tmp) > IS_UNDEF) {
Z_TRY_DELREF(tmp);
/** Separation only when refcount > 1 */
if (Z_REFCOUNTED(tmp)) {
if (Z_REFCOUNT(tmp) > 1) {
if (!Z_ISREF(tmp)) {
zval new_zv;
ZVAL_DUP(&new_zv, &tmp);
ZVAL_COPY_VALUE(&tmp, &new_zv);
Z_TRY_DELREF(new_zv);
separated = 1;
}
}
} else {
zval new_zv;
ZVAL_DUP(&new_zv, &tmp);
ZVAL_COPY_VALUE(&tmp, &new_zv);
Z_TRY_DELREF(new_zv);
separated = 1;
}
if (increment) {
zephir_increment(&tmp);
} else {
zephir_decrement(&tmp);
}
if (separated) {
zephir_update_property_zval(object, property_name, property_length, &tmp);
}
}
return SUCCESS;
}
/**
* Reads column-map information for certain model using a MODEL_* constant
*
*<code>
* print_r(
* $metaData->readColumnMapIndex(
* new Robots(),
* MetaData::MODELS_REVERSE_COLUMN_MAP
* )
* );
*</code>
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, readColumnMapIndex) {
zend_long index, ZEPHIR_LAST_CALL_STATUS;
zval *model, model_sub, *index_param = NULL, keyName, columnMapModel, map, _0, _1$$4, _2$$4, _3$$4;
zval *this_ptr = getThis();
ZVAL_UNDEF(&model_sub);
ZVAL_UNDEF(&keyName);
ZVAL_UNDEF(&columnMapModel);
ZVAL_UNDEF(&map);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1$$4);
ZVAL_UNDEF(&_2$$4);
ZVAL_UNDEF(&_3$$4);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &model, &index_param);
index = zephir_get_intval(index_param);
if (!(ZEPHIR_GLOBAL(orm).column_renaming)) {
RETURN_MM_NULL();
}
ZEPHIR_INIT_VAR(&keyName);
zephir_get_class(&keyName, model, 1 TSRMLS_CC);
ZEPHIR_OBS_VAR(&columnMapModel);
zephir_read_property(&_0, this_ptr, SL("_columnMap"), PH_NOISY_CC | PH_READONLY);
if (!(zephir_array_isset_fetch(&columnMapModel, &_0, &keyName, 0 TSRMLS_CC))) {
ZVAL_NULL(&_1$$4);
ZVAL_NULL(&_2$$4);
ZVAL_NULL(&_3$$4);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_initialize", NULL, 5, model, &_1$$4, &_2$$4, &_3$$4);
zephir_check_call_status();
zephir_read_property(&_1$$4, this_ptr, SL("_columnMap"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_OBS_NVAR(&columnMapModel);
zephir_array_fetch(&columnMapModel, &_1$$4, &keyName, PH_NOISY, "phalcon/mvc/model/metadata.zep", 369 TSRMLS_CC);
}
zephir_array_isset_long_fetch(&map, &columnMapModel, index, 1 TSRMLS_CC);
RETURN_CTOR(&map);
}