PHP_METHOD(Test_NativeArray, testArrayMultipleAccess4) {
zval *_0, *_1;
zval *a, *b, *_2, *_3, *_4;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(a);
array_init_size(a, 2);
ZEPHIR_INIT_VAR(_0);
array_init_size(_0, 2);
ZEPHIR_INIT_VAR(_1);
array_init_size(_1, 3);
ZEPHIR_INIT_VAR(_2);
ZVAL_STRING(_2, "a", 1);
zephir_array_fast_append(_1, _2);
ZEPHIR_INIT_BNVAR(_2);
ZVAL_STRING(_2, "b", 1);
zephir_array_fast_append(_1, _2);
zephir_array_fast_append(_0, _1);
zephir_array_fast_append(a, _0);
zephir_array_fetch_long(&_3, a, 0, PH_NOISY | PH_READONLY TSRMLS_CC);
zephir_array_fetch_long(&_4, _3, 0, PH_NOISY | PH_READONLY TSRMLS_CC);
zephir_array_fetch_long(&b, _4, 1, PH_NOISY | PH_READONLY TSRMLS_CC);
RETURN_CTOR(b);
}
/**
* Phalcon\Acl\Adapter\Memory constructor
*/
PHP_METHOD(Phalcon_Acl_Adapter_Memory, __construct){
zval *a0 = NULL, *a1 = NULL, *a2 = NULL;
PHALCON_MM_GROW();
phalcon_update_property_empty_array(phalcon_acl_adapter_memory_ce, this_ptr, SL("_rolesNames") TSRMLS_CC);
phalcon_update_property_empty_array(phalcon_acl_adapter_memory_ce, this_ptr, SL("_roles") TSRMLS_CC);
phalcon_update_property_empty_array(phalcon_acl_adapter_memory_ce, this_ptr, SL("_resources") TSRMLS_CC);
phalcon_update_property_empty_array(phalcon_acl_adapter_memory_ce, this_ptr, SL("_access") TSRMLS_CC);
phalcon_update_property_empty_array(phalcon_acl_adapter_memory_ce, this_ptr, SL("_roleInherits") TSRMLS_CC);
PHALCON_INIT_VAR(a0);
array_init_size(a0, 1);
add_assoc_bool_ex(a0, SS("*"), 1);
zend_update_property(phalcon_acl_adapter_memory_ce, this_ptr, SL("_resourcesNames"), a0 TSRMLS_CC);
PHALCON_INIT_VAR(a1);
array_init_size(a1, 1);
PHALCON_INIT_VAR(a2);
array_init_size(a2, 1);
add_assoc_bool_ex(a2, SS("*"), 1);
phalcon_array_update_string(&a1, SL("*"), &a2, PH_COPY | PH_SEPARATE TSRMLS_CC);
zend_update_property(phalcon_acl_adapter_memory_ce, this_ptr, SL("_accessList"), a1 TSRMLS_CC);
PHALCON_MM_RESTORE();
}
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_Properties_PropertyArray, __construct) {
zval *_1, *_3;
zval *_0, *_2;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(_0);
array_init_size(_0, 7);
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, 4);
zephir_array_fast_append(_0, _1);
zephir_update_property_this(this_ptr, SL("someArray"), _0 TSRMLS_CC);
ZEPHIR_INIT_BNVAR(_1);
array_init(_1);
zephir_update_property_this(this_ptr, SL("someEmptyArray"), _1 TSRMLS_CC);
ZEPHIR_INIT_VAR(_2);
array_init_size(_2, 2);
ZEPHIR_INIT_VAR(_3);
ZVAL_LONG(_3, 1);
zephir_array_fast_append(_2, _3);
zephir_update_property_this(this_ptr, SL("someArray"), _2 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Test_NativeArray, testArray12) {
zval *a, *b, *c, *_0;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(a);
array_init_size(a, 5);
ZEPHIR_INIT_VAR(_0);
ZVAL_LONG(_0, 1);
zephir_array_fast_append(a, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_LONG(_0, 2);
zephir_array_fast_append(a, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_LONG(_0, 3);
zephir_array_fast_append(a, _0);
ZEPHIR_INIT_VAR(b);
array_init_size(b, 2);
zephir_array_fast_append(b, a);
ZEPHIR_INIT_VAR(c);
array_init_size(c, 2);
zephir_array_fast_append(c, b);
RETURN_CCTOR(c);
}
PHP_METHOD(Test_NativeArray, testArrayUpdate5) {
zval *_1, *_2, *_3;
zval *a, *_0;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(a);
array_init_size(a, 5);
ZEPHIR_INIT_VAR(_0);
ZVAL_LONG(_0, 1);
zephir_array_fast_append(a, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_LONG(_0, 2);
zephir_array_fast_append(a, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_LONG(_0, 3);
zephir_array_fast_append(a, _0);
ZEPHIR_INIT_VAR(_1);
array_init_size(_1, 5);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_LONG(_0, 1);
zephir_array_fast_append(_1, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_LONG(_0, 2);
zephir_array_fast_append(_1, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_LONG(_0, 3);
zephir_array_fast_append(_1, _0);
zephir_array_update_long(&a, 0, &_1, PH_COPY | PH_SEPARATE, "test/nativearray.zep", 396);
ZEPHIR_INIT_VAR(_2);
array_init_size(_2, 5);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_LONG(_0, 1);
zephir_array_fast_append(_2, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_LONG(_0, 2);
zephir_array_fast_append(_2, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_LONG(_0, 3);
zephir_array_fast_append(_2, _0);
zephir_array_update_long(&a, 1, &_2, PH_COPY | PH_SEPARATE, "test/nativearray.zep", 397);
ZEPHIR_INIT_VAR(_3);
array_init_size(_3, 5);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_LONG(_0, 1);
zephir_array_fast_append(_3, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_LONG(_0, 2);
zephir_array_fast_append(_3, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_LONG(_0, 3);
zephir_array_fast_append(_3, _0);
zephir_array_update_long(&a, 2, &_3, PH_COPY | PH_SEPARATE, "test/nativearray.zep", 398);
RETURN_CCTOR(a);
}
/**
* Adds a join to the query
*
*<code>
* $criteria->join('Robots');
* $criteria->join('Robots', 'r.id = RobotsParts.robots_id');
* $criteria->join('Robots', 'r.id = RobotsParts.robots_id', 'r');
* $criteria->join('Robots', 'r.id = RobotsParts.robots_id', 'r', 'LEFT');
*</code>
*
* @param string $model
* @param string $conditions
* @param string $alias
* @param string $type
* @return Phalcon\Mvc\Model\CriteriaInterface
*/
PHP_METHOD(Phalcon_Mvc_Model_Criteria, join){
zval *model, *conditions = NULL, *alias = NULL, *type = NULL, *new_join, *params;
zval *current_joins, *merged_joins = NULL, *new_join_array = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 3, &model, &conditions, &alias, &type);
if (!conditions) {
conditions = PHALCON_GLOBAL(z_null);
}
if (!alias) {
alias = PHALCON_GLOBAL(z_null);
}
if (!type) {
type = PHALCON_GLOBAL(z_null);
}
PHALCON_INIT_VAR(new_join);
array_init_size(new_join, 4);
phalcon_array_append(&new_join, model, 0);
phalcon_array_append(&new_join, conditions, 0);
phalcon_array_append(&new_join, alias, 0);
phalcon_array_append(&new_join, type, 0);
PHALCON_OBS_VAR(params);
phalcon_read_property_this(¶ms, this_ptr, SL("_params"), PH_NOISY TSRMLS_CC);
if (phalcon_array_isset_string(params, SS("joins"))) {
PHALCON_INIT_VAR(new_join_array);
array_init_size(new_join_array, 1);
phalcon_array_append(&new_join_array, new_join, 0);
PHALCON_OBS_VAR(current_joins);
phalcon_array_fetch_string(¤t_joins, params, SL("joins"), PH_NOISY);
if (Z_TYPE_P(current_joins) == IS_ARRAY) {
PHALCON_INIT_VAR(merged_joins);
phalcon_fast_array_merge(merged_joins, ¤t_joins, &new_join_array TSRMLS_CC);
} else {
PHALCON_CPY_WRT(merged_joins, new_join_array);
}
} else {
PHALCON_INIT_NVAR(merged_joins);
array_init_size(merged_joins, 1);
phalcon_array_append(&merged_joins, new_join, 0);
}
phalcon_update_property_array_string(this_ptr, SL("_params"), SS("joins"), merged_joins TSRMLS_CC);
RETURN_THIS();
}
/**
* Test\Router constructor
*
* @param boolean defaultRoutes
*/
PHP_METHOD(Test_Router, __construct) {
zephir_fcall_cache_entry *_3 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *_1, *_5;
zval *defaultRoutes_param = NULL, *routes, *_0, *_2 = NULL, *_4;
zend_bool defaultRoutes;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &defaultRoutes_param);
if (!defaultRoutes_param) {
defaultRoutes = 1;
} else {
defaultRoutes = zephir_get_boolval(defaultRoutes_param);
}
ZEPHIR_INIT_VAR(routes);
array_init(routes);
if ((defaultRoutes == 1)) {
ZEPHIR_INIT_VAR(_0);
object_init_ex(_0, test_router_route_ce);
ZEPHIR_INIT_VAR(_1);
array_init_size(_1, 2);
add_assoc_long_ex(_1, SS("controller"), 1);
ZEPHIR_INIT_VAR(_2);
ZVAL_STRING(_2, "#^/([a-zA-Z0-9\\_\\-]+)[/]{0,1}$#", 0);
ZEPHIR_CALL_METHOD(NULL, _0, "__construct", &_3, _2, _1);
zephir_check_temp_parameter(_2);
zephir_check_call_status();
zephir_array_append(&routes, _0, PH_SEPARATE);
ZEPHIR_INIT_VAR(_4);
object_init_ex(_4, test_router_route_ce);
ZEPHIR_INIT_VAR(_5);
array_init_size(_5, 5);
add_assoc_long_ex(_5, SS("controller"), 1);
add_assoc_long_ex(_5, SS("action"), 2);
add_assoc_long_ex(_5, SS("params"), 3);
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "#^/([a-zA-Z0-9\\_\\-]+)/([a-zA-Z0-9\\.\\_]+)(/.*)*$#", 0);
ZEPHIR_CALL_METHOD(NULL, _4, "__construct", &_3, _2, _5);
zephir_check_temp_parameter(_2);
zephir_check_call_status();
zephir_array_append(&routes, _4, PH_SEPARATE);
}
ZEPHIR_INIT_NVAR(_2);
array_init(_2);
zephir_update_property_this(this_ptr, SL("_params"), _2 TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_routes"), routes TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(OAuth2_ResponseType_AuthorizationCode, getAuthorizeResponse) {
int ZEPHIR_LAST_CALL_STATUS;
zval *_1;
zval *user_id = NULL;
zval *params = NULL, *user_id_param = NULL, *result, *_0 = NULL, *_2 = NULL, *_3, *_4, *_5, *_6, *_7;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, ¶ms, &user_id_param);
ZEPHIR_SEPARATE_PARAM(params);
if (!user_id_param) {
ZEPHIR_INIT_VAR(user_id);
ZVAL_EMPTY_STRING(user_id);
} else {
zephir_get_strval(user_id, user_id_param);
}
ZEPHIR_INIT_VAR(result);
array_init_size(result, 2);
ZEPHIR_INIT_VAR(_0);
array_init(_0);
zephir_array_update_string(&result, SL("query"), &_0, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_0);
ZEPHIR_INIT_VAR(_1);
array_init_size(_1, 3);
zephir_array_update_string(&_1, SL("scope"), &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_1, SL("state"), &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
zephir_fast_array_merge(_0, &(_1), &(params) TSRMLS_CC);
ZEPHIR_CPY_WRT(params, _0);
zephir_array_fetch_string(&_3, params, SL("client_id"), PH_NOISY | PH_READONLY, "oauth2/responsetype/authorizationcode.zep", 37 TSRMLS_CC);
zephir_array_fetch_string(&_4, params, SL("redirect_uri"), PH_NOISY | PH_READONLY, "oauth2/responsetype/authorizationcode.zep", 37 TSRMLS_CC);
zephir_array_fetch_string(&_5, params, SL("scope"), PH_NOISY | PH_READONLY, "oauth2/responsetype/authorizationcode.zep", 37 TSRMLS_CC);
ZEPHIR_CALL_METHOD(&_2, this_ptr, "createauthorizationcode", NULL, _3, user_id, _4, _5);
zephir_check_call_status();
zephir_array_update_multi(&result, &_2 TSRMLS_CC, SL("ss"), 4, SL("query"), SL("code"));
if (zephir_array_isset_string(params, SS("state"))) {
zephir_array_fetch_string(&_6, params, SL("state"), PH_NOISY | PH_READONLY, "oauth2/responsetype/authorizationcode.zep", 40 TSRMLS_CC);
zephir_array_update_multi(&result, &_6 TSRMLS_CC, SL("ss"), 4, SL("query"), SL("state"));
}
array_init_size(return_value, 3);
ZEPHIR_OBS_VAR(_7);
zephir_array_fetch_string(&_7, params, SL("redirect_uri"), PH_NOISY, "oauth2/responsetype/authorizationcode.zep", 43 TSRMLS_CC);
zephir_array_fast_append(return_value, _7);
zephir_array_fast_append(return_value, result);
RETURN_MM();
}
/**
* Adds a RIGHT join to the query
*
*<code>
* $criteria->rightJoin('Robots', 'r.id = RobotsParts.robots_id', 'r');
*</code>
*
* @param string $model
* @param string $conditions
* @param string $alias
* @return Phalcon\Mvc\Model\Query\Builder
*/
PHP_METHOD(Phalcon_Mvc_Model_Criteria, rightJoin){
zval *model, *conditions = NULL, *alias = NULL, *type, *join, *params;
zval *current_joins, *merged_joins = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 2, &model, &conditions, &alias);
if (!conditions) {
PHALCON_INIT_VAR(conditions);
}
if (!alias) {
PHALCON_INIT_VAR(alias);
}
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "RIGHT", 1);
PHALCON_INIT_VAR(join);
array_init_size(join, 4);
phalcon_array_append(&join, model, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&join, conditions, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&join, alias, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&join, type, PH_SEPARATE TSRMLS_CC);
PHALCON_OBS_VAR(params);
phalcon_read_property_this(¶ms, this_ptr, SL("_params"), PH_NOISY_CC);
if (phalcon_array_isset_string(params, SS("joins"))) {
PHALCON_OBS_VAR(current_joins);
phalcon_array_fetch_string(¤t_joins, params, SL("joins"), PH_NOISY_CC);
if (Z_TYPE_P(current_joins) == IS_ARRAY) {
PHALCON_INIT_VAR(merged_joins);
phalcon_fast_array_merge(merged_joins, ¤t_joins, &join TSRMLS_CC);
} else {
PHALCON_CPY_WRT(merged_joins, join);
}
} else {
PHALCON_INIT_NVAR(merged_joins);
array_init_size(merged_joins, 1);
phalcon_array_append(&merged_joins, join, PH_SEPARATE TSRMLS_CC);
}
phalcon_update_property_array_string(this_ptr, SL("_params"), SS("joins"), merged_joins TSRMLS_CC);
RETURN_THIS();
}
/**
* Phalcon\Flash constructor
*
* @param array $cssClasses
*/
PHP_METHOD(Phalcon_Flash, __construct){
zval *css_classes = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &css_classes) == FAILURE) {
RETURN_MM_NULL();
}
if (!css_classes) {
PHALCON_INIT_VAR(css_classes);
} else {
PHALCON_SEPARATE_PARAM(css_classes);
}
if (Z_TYPE_P(css_classes) != IS_ARRAY) {
PHALCON_INIT_NVAR(css_classes);
array_init_size(css_classes, 4);
add_assoc_stringl_ex(css_classes, SS("error"), SL("errorMessage"), 1);
add_assoc_stringl_ex(css_classes, SS("notice"), SL("noticeMessage"), 1);
add_assoc_stringl_ex(css_classes, SS("success"), SL("successMessage"), 1);
add_assoc_stringl_ex(css_classes, SS("warning"), SL("warningMessage"), 1);
}
phalcon_update_property_zval(this_ptr, SL("_cssClasses"), css_classes TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Serializing a resultset will dump all related rows into a big array
*
* @return string
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, serialize){
zval *records = NULL, *cache, *column_types, *hydrate_mode;
zval *data, *serialized;
PHALCON_MM_GROW();
/**
* Obtain the records as an array
*/
PHALCON_CALL_METHOD(&records, this_ptr, "toarray");
cache = phalcon_fetch_nproperty_this(this_ptr, SL("_cache"), PH_NOISY TSRMLS_CC);
column_types = phalcon_fetch_nproperty_this(this_ptr, SL("_columnTypes"), PH_NOISY TSRMLS_CC);
hydrate_mode = phalcon_fetch_nproperty_this(this_ptr, SL("_hydrateMode"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(data);
array_init_size(data, 4);
phalcon_array_update_string(&data, SL("cache"), cache, PH_COPY);
phalcon_array_update_string(&data, SL("rows"), records, PH_COPY);
phalcon_array_update_string(&data, SL("columnTypes"), column_types, PH_COPY);
phalcon_array_update_string(&data, SL("hydrateMode"), hydrate_mode, PH_COPY);
PHALCON_INIT_VAR(serialized);
phalcon_serialize(serialized, &data TSRMLS_CC);
/**
* Avoid return bad serialized data
*/
if (Z_TYPE_P(serialized) != IS_STRING) {
RETURN_MM_NULL();
}
RETURN_CTOR(serialized);
}
/**
* Serializing a resultset will dump all related rows into a big array
*
* @return string
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, serialize){
zval *records, *cache, *column_types, *hydrate_mode;
zval *data, *serialized;
PHALCON_MM_GROW();
/**
* Obtain the records as an array
*/
PHALCON_INIT_VAR(records);
PHALCON_CALL_METHOD(records, this_ptr, "toarray");
PHALCON_OBS_VAR(cache);
phalcon_read_property_this(&cache, this_ptr, SL("_cache"), PH_NOISY_CC);
PHALCON_OBS_VAR(column_types);
phalcon_read_property_this(&column_types, this_ptr, SL("_columnTypes"), PH_NOISY_CC);
PHALCON_OBS_VAR(hydrate_mode);
phalcon_read_property_this(&hydrate_mode, this_ptr, SL("_hydrateMode"), PH_NOISY_CC);
PHALCON_INIT_VAR(data);
array_init_size(data, 4);
phalcon_array_update_string(&data, SL("cache"), &cache, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&data, SL("rows"), &records, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&data, SL("columnTypes"), &column_types, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&data, SL("hydrateMode"), &hydrate_mode, PH_COPY | PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(serialized);
PHALCON_CALL_FUNC_PARAMS_1(serialized, "serialize", data);
RETURN_CCTOR(serialized);
}
/**
* Adds a resource to the annotations handler
* A resource is a class that contains routing annotations
* The class is located in a module
*
* @param string $module
* @param string $handler
* @param string $prefix
* @return Phalcon\Mvc\Router\Annotations
*/
PHP_METHOD(Phalcon_Mvc_Router_Annotations, addModuleResource){
zval *module, *handler, *prefix = NULL, *scope;
phalcon_fetch_params(0, 2, 1, &module, &handler, &prefix);
if (!prefix) {
prefix = PHALCON_GLOBAL(z_null);
}
if (Z_TYPE_P(module) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_mvc_router_exception_ce, "The module is not a valid string");
return;
}
if (Z_TYPE_P(handler) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_mvc_router_exception_ce, "The handler must be a class name");
return;
}
MAKE_STD_ZVAL(scope);
array_init_size(scope, 3);
phalcon_array_append(&scope, prefix, 0);
phalcon_array_append(&scope, handler, 0);
phalcon_array_append(&scope, module, 0);
phalcon_update_property_array_append(this_ptr, SL("_handlers"), scope TSRMLS_CC);
zval_ptr_dtor(&scope);
phalcon_update_property_this(this_ptr, SL("_processed"), PHALCON_GLOBAL(z_false) TSRMLS_CC);
RETURN_THISW();
}
/**
* Adds a resource to the annotations handler
* A resource is a class that contains routing annotations
*
* @param string $handler
* @param string $prefix
* @return Phalcon\Mvc\Router\Annotations
*/
PHP_METHOD(Phalcon_Mvc_Router_Annotations, addResource){
zval *handler, *prefix = NULL, *scope;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &handler, &prefix);
if (!prefix) {
prefix = PHALCON_GLOBAL(z_null);
}
if (Z_TYPE_P(handler) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_router_exception_ce, "The handler must be a class name");
return;
}
PHALCON_INIT_VAR(scope);
array_init_size(scope, 2);
phalcon_array_append(&scope, prefix, 0);
phalcon_array_append(&scope, handler, 0);
phalcon_update_property_array_append(this_ptr, SL("_handlers"), scope TSRMLS_CC);
phalcon_update_property_this(this_ptr, SL("_processed"), PHALCON_GLOBAL(z_false) TSRMLS_CC);
RETURN_THIS();
}
PHP_METHOD(Test_Flow, testFor3) {
HashTable *_2;
HashPosition _1;
zval *v = NULL, *b, *c, *_0, **_3;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(c);
array_init(c);
ZEPHIR_INIT_VAR(b);
array_init_size(b, 5);
ZEPHIR_INIT_VAR(_0);
ZVAL_LONG(_0, 1);
zephir_array_fast_append(b, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_LONG(_0, 2);
zephir_array_fast_append(b, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_LONG(_0, 3);
zephir_array_fast_append(b, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_LONG(_0, 4);
zephir_array_fast_append(b, _0);
zephir_is_iterable(b, &_2, &_1, 0, 1);
for (
; zend_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zend_hash_move_backwards_ex(_2, &_1)
) {
ZEPHIR_GET_HVALUE(v, _3);
zephir_array_append(&c, v, PH_SEPARATE);
}
RETURN_CCTOR(c);
}
static ZEND_NAMED_FUNCTION(zend_closure_call_magic) /* {{{ */ {
zend_fcall_info fci;
zend_fcall_info_cache fcc;
zval params[2];
memset(&fci, 0, sizeof(zend_fcall_info));
memset(&fcc, 0, sizeof(zend_fcall_info_cache));
fci.size = sizeof(zend_fcall_info);
fci.retval = return_value;
fcc.function_handler = (zend_function *) EX(func)->common.arg_info;
fci.params = params;
fci.param_count = 2;
ZVAL_STR(&fci.params[0], EX(func)->common.function_name);
if (ZEND_NUM_ARGS()) {
array_init_size(&fci.params[1], ZEND_NUM_ARGS());
zend_copy_parameters_array(ZEND_NUM_ARGS(), &fci.params[1]);
} else {
ZVAL_EMPTY_ARRAY(&fci.params[1]);
}
fci.object = Z_OBJ(EX(This));
fcc.object = Z_OBJ(EX(This));
zend_call_function(&fci, &fcc);
zval_ptr_dtor(&fci.params[0]);
zval_ptr_dtor(&fci.params[1]);
}
/**
* Adds the limit parameter to the criteria
*
* @param int $limit
* @param int $offset
* @return Phalcon\Mvc\Model\Criteria
*/
PHP_METHOD(Phalcon_Mvc_Model_Criteria, limit){
zval *limit, *offset = NULL, *limit_clause;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &limit, &offset);
if (!offset) {
PHALCON_INIT_VAR(offset);
}
if (!phalcon_is_numeric(limit)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Rows limit parameter must be integer");
return;
}
if (Z_TYPE_P(offset) == IS_NULL) {
phalcon_update_property_array_string(this_ptr, SL("_params"), SS("limit"), limit TSRMLS_CC);
} else {
PHALCON_INIT_VAR(limit_clause);
array_init_size(limit_clause, 2);
phalcon_array_update_string(&limit_clause, SL("number"), &limit, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&limit_clause, SL("offset"), &offset, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_update_property_array_string(this_ptr, SL("_params"), SS("limit"), limit_clause TSRMLS_CC);
}
RETURN_THIS();
}
zval * yee_exception_to_array_recursive(zval *self, zval *exception) {
zend_object *object = (zend_object *)zend_object_store_get_object(self TSRMLS_CC);
zend_object *except_object = (zend_object *)zend_object_store_get_object(exception TSRMLS_CC);
zval *array;
zval *name = NULL, *message = NULL, *code = NULL, *previous = NULL, *previous2 = NULL;
MAKE_STD_ZVAL(array);
array_init_size(array, 5);
if (instanceof_function(except_object->ce, yee_ce_Exception)) {
zend_call_method(&exception, except_object->ce, NULL, ZEND_STRL("getname"), &name, 0, NULL, NULL);
}else {
MAKE_STD_ZVAL(name);
ZVAL_STRING(name, "Exception", 1);
}
zend_call_method(&exception, except_object->ce, NULL, ZEND_STRL("getmessage"), &message, 0, NULL, NULL);
zend_call_method(&exception, except_object->ce, NULL, ZEND_STRL("getcode"), &code, 0, NULL, NULL);
zend_call_method(&exception, except_object->ce, NULL, ZEND_STRL("getprevious"), &previous, 0, NULL, NULL);
add_assoc_string_ex(array, ZEND_STRS("type"), (char *)except_object->ce->name, 1);
add_assoc_zval_ex(array, ZEND_STRS("name"), name);
add_assoc_zval_ex(array, ZEND_STRS("message"), message);
add_assoc_zval_ex(array, ZEND_STRS("code"), code);
if (previous && previous->type == IS_OBJECT) {
previous2 = yee_exception_to_array_recursive(self, previous);
add_assoc_zval_ex(array, ZEND_STRS("previous"), previous2);
}
zval_dtor(previous);
efree(previous);
return array;
}
PHP_METHOD(Test_Json, testEncodeOptions) {
zval *arr, *_0 = NULL, _1;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(arr);
array_init_size(arr, 7);
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "<foo>", 1);
zephir_array_fast_append(arr, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "'bar'", 1);
zephir_array_fast_append(arr, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "&blong&", 1);
zephir_array_fast_append(arr, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_STRING(_0, "\xc3\xa9", 1);
zephir_array_fast_append(arr, _0);
ZEPHIR_SINIT_VAR(_1);
ZVAL_LONG(&_1, 1);
zephir_json_encode(return_value, &(return_value), arr, zephir_get_intval(&_1) TSRMLS_CC);
RETURN_MM();
}
PHP_METHOD(Test_NativeArray, testArrayUpdate3) {
int b;
zval *a, *_0, *_1;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(a);
array_init_size(a, 5);
ZEPHIR_INIT_VAR(_0);
ZVAL_LONG(_0, 1);
zephir_array_fast_append(a, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_LONG(_0, 2);
zephir_array_fast_append(a, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_LONG(_0, 3);
zephir_array_fast_append(a, _0);
b = 0;
ZEPHIR_INIT_BNVAR(_0);
ZVAL_LONG(_0, 4);
zephir_array_update_long(&a, b, &_0, PH_COPY | PH_SEPARATE, "test/nativearray.zep", 379);
b = 1;
ZEPHIR_INIT_VAR(_1);
ZVAL_LONG(_1, 5);
zephir_array_update_long(&a, b, &_1, PH_COPY | PH_SEPARATE, "test/nativearray.zep", 381);
RETURN_CCTOR(a);
}
/**
* Phalcon\Flash constructor
*
* @param array $cssClasses
*/
PHP_METHOD(Phalcon_Flash, __construct){
zval *css_classes = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 1, &css_classes);
if (!css_classes) {
PHALCON_INIT_VAR(css_classes);
} else {
PHALCON_SEPARATE_PARAM(css_classes);
}
if (Z_TYPE_P(css_classes) != IS_ARRAY) {
PHALCON_INIT_NVAR(css_classes);
array_init_size(css_classes, 4);
add_assoc_stringl_ex(css_classes, SS("error"), SL("errorMessage"), 1);
add_assoc_stringl_ex(css_classes, SS("notice"), SL("noticeMessage"), 1);
add_assoc_stringl_ex(css_classes, SS("success"), SL("successMessage"), 1);
add_assoc_stringl_ex(css_classes, SS("warning"), SL("warningMessage"), 1);
}
phalcon_update_property_this(this_ptr, SL("_cssClasses"), css_classes TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/* {{{ proto array SplDoublyLinkedList::__serialize() */
SPL_METHOD(SplDoublyLinkedList, __serialize)
{
spl_dllist_object *intern = Z_SPLDLLIST_P(ZEND_THIS);
spl_ptr_llist_element *current = intern->llist->head;
zval tmp;
if (zend_parse_parameters_none_throw() == FAILURE) {
return;
}
array_init(return_value);
/* flags */
ZVAL_LONG(&tmp, intern->flags);
zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &tmp);
/* elements */
array_init_size(&tmp, intern->llist->count);
while (current) {
zend_hash_next_index_insert(Z_ARRVAL(tmp), ¤t->data);
current = current->next;
}
zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &tmp);
/* members */
ZVAL_ARR(&tmp, zend_std_get_properties(&intern->std));
Z_TRY_ADDREF(tmp);
zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &tmp);
} /* }}} */
/**
* Adds a variable to the debug output
*
* @param mixed $var
* @param string $key
* @return Phalcon\Debug
*/
PHP_METHOD(Phalcon_Debug, debugVar){
zval *var, *key = NULL, *ztime, *backtrace, *data;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &var, &key);
if (!key) {
PHALCON_INIT_VAR(key);
}
PHALCON_INIT_VAR(ztime);
ZVAL_LONG(ztime, (long) time(NULL));
PHALCON_INIT_VAR(backtrace);
#if PHP_VERSION_ID < 50400
#ifdef DEBUG_BACKTRACE_PROVIDE_OBJECT
zend_fetch_debug_backtrace(backtrace, 0, DEBUG_BACKTRACE_PROVIDE_OBJECT TSRMLS_CC);
#else
zend_fetch_debug_backtrace(backtrace, 0, 1 TSRMLS_CC);
#endif
#else
zend_fetch_debug_backtrace(backtrace, 0, DEBUG_BACKTRACE_PROVIDE_OBJECT, 0 TSRMLS_CC);
#endif
PHALCON_INIT_VAR(data);
array_init_size(data, 3);
phalcon_array_append(&data, var, PH_SEPARATE);
phalcon_array_append(&data, backtrace, PH_SEPARATE);
phalcon_array_append(&data, ztime, PH_SEPARATE);
phalcon_update_property_array_append(this_ptr, SL("_data"), data TSRMLS_CC);
RETURN_THIS();
}
/**
* Returns a new Phalcon\Mvc\Model\Transaction or an already created once
* This method registers a shutdown function to rollback active connections
*
* @param boolean $autoBegin
* @return Phalcon\Mvc\Model\TransactionInterface
*/
PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, get){
zval *auto_begin = NULL, *initialized, *rollback_pendent = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 1, &auto_begin);
if (!auto_begin) {
PHALCON_INIT_VAR(auto_begin);
ZVAL_BOOL(auto_begin, 1);
}
PHALCON_OBS_VAR(initialized);
phalcon_read_property_this(&initialized, this_ptr, SL("_initialized"), PH_NOISY_CC);
if (zend_is_true(initialized)) {
PHALCON_OBS_VAR(rollback_pendent);
phalcon_read_property_this(&rollback_pendent, this_ptr, SL("_rollbackPendent"), PH_NOISY_CC);
if (zend_is_true(rollback_pendent)) {
PHALCON_INIT_NVAR(rollback_pendent);
array_init_size(rollback_pendent, 2);
phalcon_array_append(&rollback_pendent, this_ptr, PH_SEPARATE);
add_next_index_stringl(rollback_pendent, SL("rollbackPendent"), 1);
phalcon_call_func_p1_noret("register_shutdown_function", rollback_pendent);
}
phalcon_update_property_bool(this_ptr, SL("_initialized"), 1 TSRMLS_CC);
}
phalcon_call_method(return_value, this_ptr, "getorcreatetransaction");
RETURN_MM();
}
/**
* Initializes the internal handler, calling functions on it
*
* @param string $method
* @param array $arguments
* @return mixed
*/
PHP_METHOD(Phalcon_Mvc_Micro_LazyLoader, __call){
zval *method, *arguments, *handler = NULL, *definition;
zval *call_handler;
zend_class_entry *ce0;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &method, &arguments);
handler = phalcon_read_property(getThis(), SL("_handler"), PH_NOISY);
if (Z_TYPE_P(handler) != IS_OBJECT) {
definition = phalcon_read_property(getThis(), SL("_definition"), PH_NOISY);
ce0 = phalcon_fetch_class(definition);
PHALCON_INIT_NVAR(handler);
object_init_ex(handler, ce0);
if (phalcon_has_constructor(handler)) {
PHALCON_CALL_METHOD(NULL, handler, "__construct");
}
phalcon_update_property_this(getThis(), SL("_handler"), handler);
}
PHALCON_INIT_VAR(call_handler);
array_init_size(call_handler, 2);
phalcon_array_append(call_handler, handler, PH_COPY);
phalcon_array_append(call_handler, method, PH_COPY);
/**
* Call the handler
*/
PHALCON_CALL_USER_FUNC_ARRAY(&return_value, call_handler, arguments);
RETURN_MM();
}
/**
* Adds a validator to a field
*
* @param string $attribute
* @param Phalcon\Validation\ValidatorInterface
* @return Phalcon\Validation
*/
PHP_METHOD(Phalcon_Validation, add){
zval *attribute, *validator, *scope;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &attribute, &validator);
if (Z_TYPE_P(attribute) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "The attribute must be a string");
return;
}
if (Z_TYPE_P(validator) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "The validator must be an object");
return;
}
PHALCON_INIT_VAR(scope);
array_init_size(scope, 2);
phalcon_array_append(&scope, attribute, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&scope, validator, PH_SEPARATE TSRMLS_CC);
phalcon_update_property_array_append(this_ptr, SL("_validators"), scope TSRMLS_CC);
RETURN_THIS();
}
PHP_METHOD(Test_Flow, testFor1) {
HashTable *_2;
HashPosition _1;
int c;
zval *v = NULL, *b, *_0, **_3;
ZEPHIR_MM_GROW();
c = 0;
ZEPHIR_INIT_VAR(b);
array_init_size(b, 5);
ZEPHIR_INIT_VAR(_0);
ZVAL_LONG(_0, 1);
zephir_array_fast_append(b, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_LONG(_0, 2);
zephir_array_fast_append(b, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_LONG(_0, 3);
zephir_array_fast_append(b, _0);
ZEPHIR_INIT_BNVAR(_0);
ZVAL_LONG(_0, 4);
zephir_array_fast_append(b, _0);
zephir_is_iterable(b, &_2, &_1, 0, 0);
for (
; zend_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zend_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HVALUE(v, _3);
c += zephir_get_numberval(v);
}
RETURN_MM_LONG(c);
}
/**
* Initializes the internal handler, calling functions on it
*
* @param string $method
* @param array $arguments
* @return mixed
*/
PHP_METHOD(Phalcon_Mvc_Micro_LazyLoader, __call){
zval *method, *arguments, handler = {}, definition = {}, call_handler = {};
zend_class_entry *ce0;
phalcon_fetch_params(0, 2, 0, &method, &arguments);
phalcon_return_property(&handler, getThis(), SL("_handler"));
if (Z_TYPE(handler) != IS_OBJECT) {
phalcon_read_property(&definition, getThis(), SL("_definition"), PH_NOISY);
ce0 = phalcon_fetch_class(&definition, ZEND_FETCH_CLASS_DEFAULT);
PHALCON_OBJECT_INIT(&handler, ce0);
if (phalcon_has_constructor(&handler)) {
PHALCON_CALL_METHODW(NULL, &handler, "__construct");
}
phalcon_update_property_zval(getThis(), SL("_handler"), &handler);
}
array_init_size(&call_handler, 2);
phalcon_array_append(&call_handler, &handler, PH_COPY);
phalcon_array_append(&call_handler, method, PH_COPY);
/**
* Call the handler
*/
PHALCON_CALL_USER_FUNC_ARRAYW(return_value, &call_handler, arguments);
}
/**
* Executes the validation
*
* @param Phalcon\Validation $validator
* @param string $attribute
* @return boolean
*/
PHP_METHOD(Phalcon_Validation_Validator_Url, validate){
zval *validator, *attribute, *value = NULL, *allow_empty, *valid = NULL, *label;
zval *pairs, *message_str, *code, *prepared = NULL, *message;
zend_class_entry *ce = Z_OBJCE_P(getThis());
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &validator, &attribute);
PHALCON_VERIFY_CLASS_EX(validator, phalcon_validation_ce, phalcon_validation_exception_ce, 1);
PHALCON_CALL_METHOD(&value, validator, "getvalue", attribute);
PHALCON_OBS_VAR(allow_empty);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &allow_empty, getThis(), ISV(allowEmpty)));
if (zend_is_true(allow_empty) && phalcon_validation_validator_isempty_helper(value)) {
RETURN_MM_TRUE;
}
PHALCON_CALL_SELF(&valid, "valid", value);
if (PHALCON_IS_FALSE(valid)) {
PHALCON_OBS_VAR(label);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &label, getThis(), ISV(label)));
if (!zend_is_true(label)) {
PHALCON_CALL_METHOD(&label, validator, "getlabel", attribute);
if (!zend_is_true(label)) {
PHALCON_CPY_WRT(label, attribute);
}
}
PHALCON_ALLOC_INIT_ZVAL(pairs);
array_init_size(pairs, 1);
Z_TRY_ADDREF_P(label); add_assoc_zval_ex(pairs, SL(":field"), label);
PHALCON_OBS_VAR(message_str);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &message_str, getThis(), ISV(message)));
if (!zend_is_true(message_str)) {
PHALCON_OBSERVE_OR_NULLIFY_VAR(message_str);
RETURN_MM_ON_FAILURE(phalcon_validation_getdefaultmessage_helper(Z_OBJCE_P(validator), message_str, validator, "Url"));
}
PHALCON_OBS_VAR(code);
RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &code, getThis(), ISV(code)));
if (Z_TYPE_P(code) == IS_NULL) {
ZVAL_LONG(code, 0);
}
PHALCON_CALL_FUNCTION(&prepared, "strtr", message_str, pairs);
message = phalcon_validation_message_construct_helper(prepared, attribute, "Url", code);
Z_TRY_DELREF_P(message);
PHALCON_CALL_METHOD(NULL, validator, "appendmessage", message);
RETURN_MM_FALSE;
}
RETURN_MM_TRUE;
}
