/**
* Changes internal pointer to a specific position in the resultset
*/
PHP_METHOD(Phalcon_Model_Resultset, seek){
zval *position = NULL, *rows = NULL, *i = NULL;
zval *r0 = NULL, *r1 = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &position) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_FUNC_PARAMS_1(r0, "intval", position, 0x020);
phalcon_update_property_zval(this_ptr, "_pointer", strlen("_pointer"), r0 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_type", sizeof("_type")-1, PHALCON_NOISY TSRMLS_CC);
if (zend_is_true(t0)) {
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_connection", sizeof("_connection")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, "_resultResource", sizeof("_resultResource")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(t1, "dataseek", position, t2, PHALCON_NO_CHECK);
} else {
PHALCON_ALLOC_ZVAL_MM(t3);
phalcon_read_property(&t3, this_ptr, "_rows", sizeof("_rows")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(rows, t3);
Z_SET_ISREF_P(rows);
PHALCON_CALL_FUNC_PARAMS_1_NORETURN("reset", rows, 0x055);
Z_UNSET_ISREF_P(rows);
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 0);
fs_fd08_0:
PHALCON_INIT_VAR(r1);
is_smaller_function(r1, i, position TSRMLS_CC);
if (!zend_is_true(r1)) {
goto fe_fd08_0;
}
Z_SET_ISREF_P(rows);
PHALCON_CALL_FUNC_PARAMS_1_NORETURN("next", rows, 0x059);
Z_UNSET_ISREF_P(rows);
PHALCON_SEPARATE(i);
increment_function(i);
goto fs_fd08_0;
fe_fd08_0:
if(0){}
}
PHALCON_MM_RESTORE();
}
void test_phalcon_separate(void)
{
startup_php(__func__);
zend_first_try {
zval* x;
zval* orig;
MAKE_STD_ZVAL(x);
ZVAL_LONG(x, 0xB61964F6l);
Z_ADDREF_P(x);
Z_ADDREF_P(x);
Z_ADDREF_P(x);
orig = x;
CU_ASSERT_EQUAL(Z_REFCOUNT_P(x), 4);
CU_ASSERT_EQUAL(Z_ISREF_P(x), 0);
PHALCON_SEPARATE(x);
CU_ASSERT_EQUAL(Z_REFCOUNT_P(x), 1);
CU_ASSERT_EQUAL(Z_ISREF_P(x), 0);
CU_ASSERT_PTR_NOT_EQUAL(x, orig);
CU_ASSERT_EQUAL(Z_REFCOUNT_P(orig), 3);
CU_ASSERT_EQUAL(Z_ISREF_P(orig), 0);
CU_ASSERT_EQUAL(Z_TYPE_P(x), IS_LONG);
CU_ASSERT_EQUAL(Z_LVAL_P(x), 0xB61964F6l);
CU_ASSERT_EQUAL(Z_TYPE_P(x), Z_TYPE_P(orig));
CU_ASSERT_EQUAL(Z_LVAL_P(x), Z_LVAL_P(orig));
zval_ptr_dtor(&orig);
CU_ASSERT_EQUAL(_mem_block_check(x, 1 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC), 1);
CU_ASSERT_EQUAL(_mem_block_check(orig, 1 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC), 1);
CU_ASSERT_EQUAL(Z_REFCOUNT_P(orig), 2);
zval_ptr_dtor(&x);
CU_ASSERT_EQUAL(_mem_block_check(orig, 1 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC), 1);
CU_ASSERT_EQUAL(Z_REFCOUNT_P(orig), 2);
zval_ptr_dtor(&orig);
CU_ASSERT_EQUAL(_mem_block_check(orig, 1 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC), 1);
CU_ASSERT_EQUAL(Z_REFCOUNT_P(orig), 1);
zval_ptr_dtor(&orig);
}
zend_catch {
CU_ASSERT(0);
}
zend_end_try();
shutdown_php();
CU_ASSERT_EQUAL(leaks, 0);
}
/**
* Appends a NOT BETWEEN condition to the current conditions
*
*<code>
* $criteria->notBetweenWhere('price', 100.25, 200.50);
*</code>
*
* @param string $expr
* @param mixed $minimum
* @param mixed $maximum
* @return Phalcon\Mvc\Model\Query\Builder
*/
PHP_METHOD(Phalcon_Mvc_Model_Criteria, notBetweenWhere){
zval *expr, *minimum, *maximum, *hidden_param, *one;
zval *next_hidden_param, *minimum_key, *maximum_key;
zval *conditions, *bind_params;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 3, 0, &expr, &minimum, &maximum);
PHALCON_OBS_VAR(hidden_param);
phalcon_read_property_this(&hidden_param, this_ptr, SL("_hiddenParamNumber"), PH_NOISY_CC);
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
PHALCON_INIT_VAR(next_hidden_param);
phalcon_add_function(next_hidden_param, hidden_param, one TSRMLS_CC);
/**
* Minimum key with auto bind-params
*/
PHALCON_INIT_VAR(minimum_key);
PHALCON_CONCAT_SV(minimum_key, "phb", hidden_param);
/**
* Maximum key with auto bind-params
*/
PHALCON_INIT_VAR(maximum_key);
PHALCON_CONCAT_SV(maximum_key, "phb", next_hidden_param);
/**
* Create a standard BETWEEN condition with bind params
*/
PHALCON_INIT_VAR(conditions);
PHALCON_CONCAT_VSVSVS(conditions, expr, " NOT BETWEEN :", minimum_key, ": AND :", maximum_key, ":");
PHALCON_INIT_VAR(bind_params);
array_init_size(bind_params, 2);
phalcon_array_update_zval(&bind_params, minimum_key, &minimum, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_zval(&bind_params, maximum_key, &maximum, PH_COPY | PH_SEPARATE TSRMLS_CC);
/**
* Append the BETWEEN to the current conditions using and 'and'
*/
phalcon_call_method_p2_noret(this_ptr, "andwhere", conditions, bind_params);
PHALCON_SEPARATE(next_hidden_param);
phalcon_increment(next_hidden_param);
phalcon_update_property_this(this_ptr, SL("_hiddenParamNumber"), next_hidden_param TSRMLS_CC);
RETURN_THIS();
}
/**
* Changes internal pointer to a specific position in the resultset
*
* @param int $position
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset, seek){
zval *position = NULL, *int_position = NULL, *type = NULL, *result = NULL, *rows = NULL;
zval *i = NULL;
zval *r0 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &position) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(int_position);
PHALCON_CALL_FUNC_PARAMS_1(int_position, "intval", position);
phalcon_update_property_zval(this_ptr, SL("_pointer"), int_position TSRMLS_CC);
PHALCON_INIT_VAR(type);
phalcon_read_property(&type, this_ptr, SL("_type"), PH_NOISY_CC);
if (zend_is_true(type)) {
PHALCON_INIT_VAR(result);
phalcon_read_property(&result, this_ptr, SL("_result"), PH_NOISY_CC);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(result, "dataseek", position, PH_NO_CHECK);
} else {
PHALCON_INIT_VAR(rows);
phalcon_read_property(&rows, this_ptr, SL("_rows"), PH_NOISY_CC);
Z_SET_ISREF_P(rows);
PHALCON_CALL_FUNC_PARAMS_1_NORETURN("reset", rows);
Z_UNSET_ISREF_P(rows);
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 0);
fs_ebc1_0:
PHALCON_INIT_VAR(r0);
is_smaller_function(r0, i, position TSRMLS_CC);
if (!zend_is_true(r0)) {
goto fe_ebc1_0;
}
Z_SET_ISREF_P(rows);
PHALCON_CALL_FUNC_PARAMS_1_NORETURN("next", rows);
Z_UNSET_ISREF_P(rows);
PHALCON_SEPARATE(i);
increment_function(i);
goto fs_ebc1_0;
fe_ebc1_0:
if(0){}
}
PHALCON_MM_RESTORE();
}
/**
* Moves internal resulset cursor to another position letting us to fetch a certain row
*
* @param int $number
*/
PHP_METHOD(Phalcon_Db_Result_Pdo, dataSeek) {
zval *number = NULL, *n = NULL, *pdo_statement = NULL, *result = NULL;
zval *r0 = NULL, *r1 = NULL;
zval *t0 = NULL, *t1 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &number) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_SEPARATE_PARAM(number);
PHALCON_INIT_VAR(t1);
ZVAL_LONG(t1, 1);
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, -1);
PHALCON_ALLOC_ZVAL_MM(r0);
mul_function(r0, t0, t1 TSRMLS_CC);
PHALCON_CPY_WRT(n, r0);
decrement_function(number);
PHALCON_INIT_VAR(pdo_statement);
phalcon_read_property(&pdo_statement, this_ptr, SL("_pdoStatement"), PH_NOISY_CC);
PHALCON_CALL_METHOD_NORETURN(pdo_statement, "execute", PH_NO_CHECK);
ws_a5eb_0:
PHALCON_INIT_VAR(r1);
is_not_equal_function(r1, n, number TSRMLS_CC);
if (!zend_is_true(r1)) {
goto we_a5eb_0;
}
PHALCON_INIT_VAR(result);
PHALCON_CALL_METHOD(result, pdo_statement, "fetch", PH_NO_CHECK);
if (Z_TYPE_P(result) != IS_ARRAY) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_SEPARATE(n);
increment_function(n);
goto ws_a5eb_0;
we_a5eb_0:
if(0) {}
PHALCON_MM_RESTORE();
}
/**
* Returns a slice of the resultset to show in the pagination
*
* @return stdClass
*/
PHP_METHOD(Phalcon_Paginator_Adapter_Sql, getPaginate){
zval db = {}, sql = {}, total_sql = {}, bind = {}, limit = {}, number_page = {}, number = {}, fetch_mode = {}, items = {}, row = {}, rowcount = {};
long int i_limit, i_number_page, i_number, i_before, i_rowcount;
long int i_total_pages, i_next;
ldiv_t tp;
phalcon_return_property(&db, getThis(), SL("_db"));
phalcon_return_property(&sql, getThis(), SL("_sql"));
phalcon_return_property(&total_sql, getThis(), SL("_total_sql"));
phalcon_return_property(&bind, getThis(), SL("_bind"));
phalcon_return_property(&limit, getThis(), SL("_limitRows"));
phalcon_return_property(&number_page, getThis(), SL("_page"));
phalcon_return_property(&fetch_mode, getThis(), SL("_fetchMode"));
i_limit = phalcon_get_intval(&limit);
i_number_page = phalcon_get_intval(&number_page);
if (i_limit < 1) {
/* This should never happen unless someone deliberately modified the properties of the object */
i_limit = 10;
}
if (!i_number_page) {
i_number_page = 1;
}
i_number = (i_number_page - 1) * i_limit;
i_before = (i_number_page == 1) ? 1 : (i_number_page - 1);
PHALCON_CALL_METHODW(&row, &db, "fetchone", &total_sql, &fetch_mode, &bind);
phalcon_return_property(&rowcount, &row, SL("rowcount"));
PHALCON_SEPARATE(&bind);
/* Set the limit clause avoiding negative offsets */
if (i_number < i_limit) {
phalcon_array_update_str(&bind, SL("limit"), &limit, PH_COPY);
phalcon_array_update_str_long(&bind, SL("offset"), 0, 0);
} else {
ZVAL_LONG(&number, i_number);
phalcon_array_update_str(&bind, SL("limit"), &limit, PH_COPY);
phalcon_array_update_str(&bind, SL("offset"), &number, PH_COPY);
}
PHALCON_CALL_METHODW(&items, &db, "fetchall", &sql, &fetch_mode, &bind);
i_rowcount = phalcon_get_intval(&rowcount);
tp = ldiv(i_rowcount, i_limit);
i_total_pages = tp.quot + (tp.rem ? 1 : 0);
i_next = (i_number_page < i_total_pages) ? (i_number_page + 1) : i_total_pages;
object_init(return_value);
phalcon_update_property_zval(return_value, SL("items"), &items);
phalcon_update_property_long(return_value, SL("before"), i_before);
phalcon_update_property_long(return_value, SL("first"), 1);
phalcon_update_property_long(return_value, SL("next"), i_next);
phalcon_update_property_long(return_value, SL("last"), i_total_pages);
phalcon_update_property_long(return_value, SL("current"), i_number_page);
phalcon_update_property_long(return_value, SL("total_pages"), i_total_pages);
phalcon_update_property_long(return_value, SL("total_items"), i_rowcount);
}
/**
* Handles routing information received from the rewrite engine
*
* @param string $uri
*/
PHP_METHOD(Phalcon_Mvc_Router, handle){
zval *uri = NULL, *real_uri = NULL, *request = NULL, *route_found = NULL, *parts = NULL;
zval *params = NULL, *matches = NULL, *routes = NULL, *reversed_routes = NULL;
zval *route = NULL, *methods = NULL, *dependency_injector = NULL;
zval *match_method = NULL, *pattern = NULL, *paths = NULL, *position = NULL;
zval *part = NULL, *match_position = NULL, *module = NULL, *default_module = NULL;
zval *controller = NULL, *default_controller = NULL, *action = NULL;
zval *default_action = NULL, *params_str = NULL, *str_params = NULL;
zval *params_merge = NULL, *default_params = NULL;
zval *c0 = NULL, *c1 = NULL, *c2 = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &uri) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!uri) {
PHALCON_ALLOC_ZVAL_MM(uri);
ZVAL_NULL(uri);
}
if (!zend_is_true(uri)) {
PHALCON_INIT_VAR(real_uri);
PHALCON_CALL_METHOD(real_uri, this_ptr, "_getrewriteuri", PH_NO_CHECK);
} else {
PHALCON_CPY_WRT(real_uri, uri);
}
PHALCON_INIT_VAR(request);
ZVAL_NULL(request);
PHALCON_INIT_VAR(route_found);
ZVAL_BOOL(route_found, 0);
PHALCON_INIT_VAR(parts);
array_init(parts);
PHALCON_INIT_VAR(params);
array_init(params);
PHALCON_INIT_VAR(matches);
array_init(matches);
phalcon_update_property_bool(this_ptr, SL("_wasMatched"), 0 TSRMLS_CC);
PHALCON_INIT_VAR(routes);
phalcon_read_property(&routes, this_ptr, SL("_routes"), PH_NOISY_CC);
PHALCON_INIT_VAR(reversed_routes);
PHALCON_CALL_FUNC_PARAMS_1(reversed_routes, "array_reverse", routes);
if (!phalcon_valid_foreach(reversed_routes TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(reversed_routes);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_c9ff_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_c9ff_0;
}
PHALCON_INIT_VAR(route);
ZVAL_ZVAL(route, *hd, 1, 0);
PHALCON_INIT_VAR(methods);
PHALCON_CALL_METHOD(methods, route, "gethttpmethods", PH_NO_CHECK);
if (Z_TYPE_P(methods) != IS_NULL) {
if (Z_TYPE_P(request) == IS_NULL) {
PHALCON_INIT_VAR(dependency_injector);
phalcon_read_property(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_dispatcher_exception_ce, "A dependency injection container is required to access the 'request' service");
return;
}
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "request", 1);
PHALCON_INIT_VAR(request);
PHALCON_CALL_METHOD_PARAMS_1(request, dependency_injector, "getshared", c0, PH_NO_CHECK);
}
PHALCON_INIT_VAR(match_method);
PHALCON_CALL_METHOD_PARAMS_1(match_method, request, "ismethod", methods, PH_NO_CHECK);
if (!zend_is_true(match_method)) {
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_c9ff_0;
}
}
PHALCON_INIT_VAR(pattern);
PHALCON_CALL_METHOD(pattern, route, "getcompiledpattern", PH_NO_CHECK);
Z_SET_ISREF_P(matches);
PHALCON_INIT_VAR(route_found);
PHALCON_CALL_FUNC_PARAMS_3(route_found, "preg_match", pattern, real_uri, matches);
Z_UNSET_ISREF_P(matches);
if (zend_is_true(route_found)) {
PHALCON_INIT_VAR(paths);
PHALCON_CALL_METHOD(paths, route, "getpaths", PH_NO_CHECK);
PHALCON_CPY_WRT(parts, paths);
if (!phalcon_valid_foreach(paths TSRMLS_CC)) {
return;
}
ah1 = Z_ARRVAL_P(paths);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
fes_c9ff_1:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_c9ff_1;
}
PHALCON_INIT_VAR(part);
PHALCON_GET_FOREACH_KEY(part, ah1, hp1);
PHALCON_INIT_VAR(position);
ZVAL_ZVAL(position, *hd, 1, 0);
eval_int = phalcon_array_isset(matches, position);
if (eval_int) {
PHALCON_INIT_VAR(match_position);
phalcon_array_fetch(&match_position, matches, position, PH_NOISY_CC);
phalcon_array_update_zval(&parts, part, &match_position, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_c9ff_1;
fee_c9ff_1:
phalcon_update_property_zval(this_ptr, SL("_matches"), matches TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_matchedRoute"), route TSRMLS_CC);
goto fee_c9ff_0;
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_c9ff_0;
fee_c9ff_0:
if (zend_is_true(route_found)) {
eval_int = phalcon_array_isset_string(parts, SL("module")+1);
if (eval_int) {
PHALCON_INIT_VAR(module);
phalcon_array_fetch_string(&module, parts, SL("module"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_module"), module TSRMLS_CC);
PHALCON_SEPARATE(parts);
phalcon_array_unset_string(parts, SL("module")+1);
} else {
PHALCON_INIT_VAR(default_module);
phalcon_read_property(&default_module, this_ptr, SL("_defaultModule"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_module"), default_module TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(parts, SL("controller")+1);
if (eval_int) {
PHALCON_INIT_VAR(controller);
phalcon_array_fetch_string(&controller, parts, SL("controller"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_controller"), controller TSRMLS_CC);
PHALCON_SEPARATE(parts);
phalcon_array_unset_string(parts, SL("controller")+1);
} else {
PHALCON_INIT_VAR(default_controller);
phalcon_read_property(&default_controller, this_ptr, SL("_defaultController"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_controller"), default_controller TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(parts, SL("action")+1);
if (eval_int) {
PHALCON_INIT_VAR(action);
phalcon_array_fetch_string(&action, parts, SL("action"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_action"), action TSRMLS_CC);
PHALCON_SEPARATE(parts);
phalcon_array_unset_string(parts, SL("action")+1);
} else {
PHALCON_INIT_VAR(default_action);
phalcon_read_property(&default_action, this_ptr, SL("_defaultAction"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_action"), default_action TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(parts, SL("params")+1);
if (eval_int) {
PHALCON_INIT_VAR(params_str);
phalcon_array_fetch_string(¶ms_str, parts, SL("params"), PH_NOISY_CC);
PHALCON_INIT_VAR(c1);
ZVAL_LONG(c1, 1);
PHALCON_INIT_VAR(str_params);
PHALCON_CALL_FUNC_PARAMS_2(str_params, "substr", params_str, c1);
if (zend_is_true(str_params)) {
PHALCON_INIT_VAR(c2);
ZVAL_STRING(c2, "/", 1);
PHALCON_INIT_VAR(params);
phalcon_fast_explode(params, c2, str_params TSRMLS_CC);
}
PHALCON_SEPARATE(parts);
phalcon_array_unset_string(parts, SL("params")+1);
}
PHALCON_INIT_VAR(params_merge);
PHALCON_CALL_FUNC_PARAMS_2(params_merge, "array_merge", params, parts);
phalcon_update_property_zval(this_ptr, SL("_params"), params_merge TSRMLS_CC);
phalcon_update_property_bool(this_ptr, SL("_wasMatched"), 1 TSRMLS_CC);
} else {
PHALCON_INIT_VAR(default_module);
phalcon_read_property(&default_module, this_ptr, SL("_defaultModule"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_module"), default_module TSRMLS_CC);
PHALCON_INIT_VAR(default_controller);
phalcon_read_property(&default_controller, this_ptr, SL("_defaultController"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_controller"), default_controller TSRMLS_CC);
PHALCON_INIT_VAR(default_action);
phalcon_read_property(&default_action, this_ptr, SL("_defaultAction"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_action"), default_action TSRMLS_CC);
PHALCON_INIT_VAR(default_params);
phalcon_read_property(&default_params, this_ptr, SL("_defaultParams"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_params"), default_params TSRMLS_CC);
phalcon_update_property_bool(this_ptr, SL("_wasMatched"), 0 TSRMLS_CC);
}
PHALCON_MM_RESTORE();
}
/**
* Handles routing information received from the rewrite engine
*
* @param string $uri
*/
PHP_METHOD(Phalcon_Router_Rewrite, handle) {
zval *uri = NULL, *parts = NULL, *params = NULL, *number_parts = NULL, *i = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL;
zval *c0 = NULL;
zval *t0 = NULL, *t1 = NULL;
zval *a0 = NULL;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &uri) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!uri) {
PHALCON_INIT_VAR(uri);
ZVAL_NULL(uri);
} else {
PHALCON_SEPARATE_PARAM(uri);
}
if (!zend_is_true(uri)) {
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD(r0, this_ptr, "_getrewriteuri", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(uri, r0);
}
if (zend_is_true(uri)) {
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "/", 1);
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_fast_explode(r1, c0, uri TSRMLS_CC);
PHALCON_CPY_WRT(parts, r1);
eval_int = phalcon_array_isset_long(parts, 0);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r2);
phalcon_array_fetch_long(&r2, parts, 0, PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r3);
phalcon_filter_alphanum(r3, r2);
phalcon_update_property_zval(this_ptr, "_controller", strlen("_controller"), r3 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_controller", sizeof("_controller")-1, PHALCON_NOISY TSRMLS_CC);
if (!zend_is_true(t0)) {
phalcon_update_property_null(this_ptr, "_controller", strlen("_controller") TSRMLS_CC);
}
} else {
phalcon_update_property_null(this_ptr, "_controller", strlen("_controller") TSRMLS_CC);
}
eval_int = phalcon_array_isset_long(parts, 1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r4);
phalcon_array_fetch_long(&r4, parts, 1, PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r5);
phalcon_filter_alphanum(r5, r4);
phalcon_update_property_zval(this_ptr, "_action", strlen("_action"), r5 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_action", sizeof("_action")-1, PHALCON_NOISY TSRMLS_CC);
if (!zend_is_true(t1)) {
phalcon_update_property_null(this_ptr, "_action", strlen("_action") TSRMLS_CC);
}
} else {
phalcon_update_property_null(this_ptr, "_action", strlen("_action") TSRMLS_CC);
}
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(params, a0);
PHALCON_ALLOC_ZVAL_MM(r6);
phalcon_fast_count(r6, parts TSRMLS_CC);
PHALCON_CPY_WRT(number_parts, r6);
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 2);
fs_ef57_0:
PHALCON_INIT_VAR(r7);
is_smaller_function(r7, i, number_parts TSRMLS_CC);
if (!zend_is_true(r7)) {
goto fe_ef57_0;
}
PHALCON_INIT_VAR(r8);
phalcon_array_fetch(&r8, parts, i, PHALCON_NOISY TSRMLS_CC);
phalcon_array_append(¶ms, r8, PHALCON_SEPARATE_PLZ TSRMLS_CC);
PHALCON_SEPARATE(i);
increment_function(i);
goto fs_ef57_0;
fe_ef57_0:
phalcon_update_property_zval(this_ptr, "_params", strlen("_params"), params TSRMLS_CC);
} else {
phalcon_update_property_null(this_ptr, "_controller", strlen("_controller") TSRMLS_CC);
phalcon_update_property_null(this_ptr, "_action", strlen("_action") TSRMLS_CC);
}
PHALCON_MM_RESTORE();
}
/**
* Dispatches a controller action taking into account the routing parameters
*
* @param Phalcon_Request $request
* @param Phalcon_Response $response
* @param Phalcon_View $view
* @param Phalcon_Model_Manager $model
* @return Phalcon_Controller
*/
PHP_METHOD(Phalcon_Dispatcher, dispatch){
zval *request = NULL, *response = NULL, *view = NULL, *model = NULL, *controllers_dir = NULL;
zval *value = NULL, *controller = NULL, *number_dispatches = NULL;
zval *controller_name = NULL, *controllers = NULL, *controller_class = NULL;
zval *controller_path = NULL, *params = NULL, *action_name = NULL;
zval *action_method = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL, *t6 = NULL;
zval *t7 = NULL, *t8 = NULL, *t9 = NULL, *t10 = NULL;
zval *c0 = NULL, *c1 = NULL, *c2 = NULL;
zval *i0 = NULL;
zval *a0 = NULL, *a1 = NULL;
zval *p0[] = { NULL, NULL, NULL, NULL, NULL };
int eval_int;
zend_class_entry *ce0;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|zz", &request, &response, &view, &model) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!view) {
PHALCON_INIT_VAR(view);
ZVAL_NULL(view);
}
if (!model) {
PHALCON_INIT_VAR(model);
ZVAL_NULL(model);
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_basePath"), PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, SL("_controllersDir"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CONCAT_VV(r0, t0, t1);
PHALCON_CPY_WRT(controllers_dir, r0);
PHALCON_INIT_VAR(value);
ZVAL_NULL(value);
PHALCON_INIT_VAR(controller);
ZVAL_NULL(controller);
PHALCON_INIT_VAR(number_dispatches);
ZVAL_LONG(number_dispatches, 0);
phalcon_update_property_bool(this_ptr, SL("_finished"), 0 TSRMLS_CC);
ws_e10f_0:
PHALCON_INIT_VAR(t2);
phalcon_read_property(&t2, this_ptr, SL("_finished"), PHALCON_NOISY TSRMLS_CC);
if (zend_is_true(t2)) {
goto we_e10f_0;
}
phalcon_update_property_bool(this_ptr, SL("_finished"), 1 TSRMLS_CC);
PHALCON_INIT_VAR(t3);
phalcon_read_property(&t3, this_ptr, SL("_controllerName"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(controller_name, t3);
if (!zend_is_true(controller_name)) {
PHALCON_INIT_VAR(t4);
phalcon_read_property(&t4, this_ptr, SL("_defaultController"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(controller_name, t4);
phalcon_update_property_zval(this_ptr, SL("_controllerName"), controller_name TSRMLS_CC);
}
PHALCON_INIT_VAR(t5);
phalcon_read_property(&t5, this_ptr, SL("_controllers"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(controllers, t5);
PHALCON_INIT_VAR(r1);
PHALCON_INIT_VAR(r2);
PHALCON_CALL_STATIC_PARAMS_1(r2, "phalcon_text", "camelize", controller_name);
PHALCON_CONCAT_VS(r1, r2, "Controller");
PHALCON_CPY_WRT(controller_class, r1);
eval_int = phalcon_array_isset(controllers, controller_class);
if (!eval_int) {
PHALCON_INIT_VAR(c0);
ZVAL_BOOL(c0, 0);
PHALCON_INIT_VAR(r3);
PHALCON_CALL_FUNC_PARAMS_2(r3, "class_exists", controller_class, c0);
if (!zend_is_true(r3)) {
PHALCON_INIT_VAR(r4);
PHALCON_CONCAT_VVS(r4, controllers_dir, controller_class, ".php");
PHALCON_CPY_WRT(controller_path, r4);
if (phalcon_file_exists(controller_path TSRMLS_CC) == SUCCESS) {
if (phalcon_require(controller_path TSRMLS_CC) == FAILURE) {
return;
}
} else {
PHALCON_INIT_VAR(r5);
PHALCON_CONCAT_SVS(r5, "File for controller class ", controller_class, " doesn't exist");
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "_throwdispatchexception", response, r5, PHALCON_NO_CHECK);
}
PHALCON_INIT_VAR(c1);
ZVAL_BOOL(c1, 0);
PHALCON_INIT_VAR(r6);
PHALCON_CALL_FUNC_PARAMS_2(r6, "class_exists", controller_class, c1);
if (!zend_is_true(r6)) {
PHALCON_INIT_VAR(r7);
PHALCON_CONCAT_SVS(r7, "Class ", controller_class, " was not found on controller file");
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "_throwdispatchexception", response, r7, PHALCON_NO_CHECK);
}
}
ce0 = phalcon_fetch_class(controller_class TSRMLS_CC);
PHALCON_INIT_VAR(i0);
object_init_ex(i0, ce0);
p0[0] = this_ptr;
p0[1] = request;
p0[2] = response;
p0[3] = view;
p0[4] = model;
PHALCON_CALL_METHOD_PARAMS_NORETURN(i0, "__construct", 5, p0, PHALCON_CHECK);
PHALCON_CPY_WRT(controller, i0);
if (phalcon_method_exists_ex(controller, SL("initialize") TSRMLS_CC) == SUCCESS) {
PHALCON_CALL_METHOD_NORETURN(controller, "initialize", PHALCON_NO_CHECK);
}
PHALCON_INIT_VAR(t6);
phalcon_read_property(&t6, this_ptr, SL("_controllers"), PHALCON_NOISY TSRMLS_CC);
phalcon_array_update(&t6, controller_class, &controller, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_controllers"), t6 TSRMLS_CC);
} else {
PHALCON_INIT_VAR(r8);
phalcon_array_fetch(&r8, controllers, controller_class, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(controller, r8);
}
PHALCON_INIT_VAR(t7);
phalcon_read_property(&t7, this_ptr, SL("_params"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(params, t7);
PHALCON_INIT_VAR(t8);
phalcon_read_property(&t8, this_ptr, SL("_actionName"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(action_name, t8);
if (!zend_is_true(action_name)) {
PHALCON_INIT_VAR(t9);
phalcon_read_property(&t9, this_ptr, SL("_defaultAction"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(action_name, t9);
phalcon_update_property_zval(this_ptr, SL("_actionName"), action_name TSRMLS_CC);
}
if (phalcon_method_exists_ex(controller, SL("beforedispatch") TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_VAR(r9);
PHALCON_CALL_METHOD_PARAMS_3(r9, controller, "beforedispatch", controller_name, action_name, params, PHALCON_NO_CHECK);
if (Z_TYPE_P(r9) == IS_BOOL && !Z_BVAL_P(r9)) {
PHALCON_INIT_VAR(value);
ZVAL_BOOL(value, 0);
goto we_e10f_0;
}
}
PHALCON_INIT_VAR(r10);
PHALCON_CONCAT_VS(r10, action_name, "Action");
PHALCON_CPY_WRT(action_method, r10);
if (phalcon_method_exists(controller, action_method TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_VAR(a0);
array_init(a0);
phalcon_array_append(&a0, controller, PHALCON_SEPARATE_PLZ TSRMLS_CC);
phalcon_array_append(&a0, action_method, PHALCON_SEPARATE_PLZ TSRMLS_CC);
PHALCON_INIT_VAR(value);
PHALCON_CALL_FUNC_PARAMS_2(value, "call_user_func_array", a0, params);
} else {
if (phalcon_method_exists_ex(controller, SL("notfoundaction") TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_VAR(a1);
array_init(a1);
phalcon_array_append(&a1, controller, PHALCON_SEPARATE_PLZ TSRMLS_CC);
add_next_index_stringl(a1, SL("notFoundAction"), 1);
PHALCON_INIT_VAR(value);
PHALCON_CALL_FUNC_PARAMS_2(value, "call_user_func_array", a1, params);
} else {
PHALCON_INIT_VAR(r11);
PHALCON_CONCAT_SVSVS(r11, "Action '", action_name, "' was not found on controller '", controller_name, "'");
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "_throwdispatchexception", response, r11, PHALCON_NO_CHECK);
}
}
if (phalcon_method_exists_ex(controller, SL("afterdispatch") TSRMLS_CC) == SUCCESS) {
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(controller, "afterdispatch", controller_name, action_name, params, PHALCON_NO_CHECK);
}
PHALCON_SEPARATE(number_dispatches);
increment_function(number_dispatches);
PHALCON_INIT_VAR(t10);
ZVAL_LONG(t10, 256);
PHALCON_INIT_VAR(r12);
is_smaller_function(r12, t10, number_dispatches TSRMLS_CC);
if (zend_is_true(r12)) {
PHALCON_INIT_VAR(c2);
ZVAL_STRING(c2, "Dispatcher has detected a cyclic routing causing stability problems", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "_throwdispatchexception", response, c2, PHALCON_NO_CHECK);
}
goto ws_e10f_0;
we_e10f_0:
phalcon_update_property_zval(this_ptr, SL("_returnedValue"), value TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_lastController"), controller TSRMLS_CC);
RETURN_CHECK_CTOR(controller);
}
/**
* Appends a NOT IN condition to the current conditions
*
*<code>
* $criteria->notInWhere('id', [1, 2, 3]);
*</code>
*
* @param string $expr
* @param array $values
* @return Phalcon\Mvc\Model\Query\Builder
*/
PHP_METHOD(Phalcon_Mvc_Model_Criteria, notInWhere){
zval *expr, *values, *hidden_param, *bind_params;
zval *bind_keys, *value = NULL, *key = NULL, *query_key = NULL, *joined_keys;
zval *conditions;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &expr, &values);
if (Z_TYPE_P(values) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Values must be an array");
return;
}
PHALCON_OBS_VAR(hidden_param);
phalcon_read_property_this(&hidden_param, this_ptr, SL("_hiddenParamNumber"), PH_NOISY_CC);
PHALCON_INIT_VAR(bind_params);
array_init(bind_params);
PHALCON_INIT_VAR(bind_keys);
array_init(bind_keys);
phalcon_is_iterable(values, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(value);
/**
* Key with auto bind-params
*/
PHALCON_INIT_NVAR(key);
PHALCON_CONCAT_SV(key, "phi", hidden_param);
PHALCON_INIT_NVAR(query_key);
PHALCON_CONCAT_SVS(query_key, ":", key, ":");
phalcon_array_append(&bind_keys, query_key, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_zval(&bind_params, key, &value, PH_COPY | PH_SEPARATE TSRMLS_CC);
PHALCON_SEPARATE(hidden_param);
phalcon_increment(hidden_param);
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_VAR(joined_keys);
phalcon_fast_join_str(joined_keys, SL(", "), bind_keys TSRMLS_CC);
/**
* Create a standard IN condition with bind params
*/
PHALCON_INIT_VAR(conditions);
PHALCON_CONCAT_VSVS(conditions, expr, " NOT IN (", joined_keys, ")");
/**
* Append the IN to the current conditions using and 'and'
*/
phalcon_call_method_p2_noret(this_ptr, "andwhere", conditions, bind_params);
phalcon_update_property_this(this_ptr, SL("_hiddenParamNumber"), hidden_param TSRMLS_CC);
RETURN_THIS();
}
/**
* Returns a slice of the resultset to show in the pagination
*
* @return stdClass
*/
PHP_METHOD(Phalcon_Paginator_Adapter_Model, getPaginate){
zval *show = NULL, *config = NULL, *items = NULL, *page_number = NULL, *zero = NULL, *one = NULL;
zval *smaller = NULL, *n = NULL, *page = NULL, *last_show_page = NULL, *start = NULL;
zval *last_page = NULL, *possible_pages = NULL, *total_pages = NULL;
zval *compare = NULL, *page_items = NULL, *i = NULL, *valid = NULL, *current = NULL, *maximum_pages = NULL;
zval *next = NULL, *additional_page = NULL, *before = NULL, *remainder = NULL;
zval *pages_total = NULL;
zval *r0 = NULL;
zval *t0 = NULL;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(show);
phalcon_read_property(&show, this_ptr, SL("_limitRows"), PH_NOISY_CC);
PHALCON_INIT_VAR(config);
phalcon_read_property(&config, this_ptr, SL("_config"), PH_NOISY_CC);
PHALCON_INIT_VAR(items);
phalcon_array_fetch_string(&items, config, SL("data"), PH_NOISY_CC);
PHALCON_INIT_VAR(page_number);
phalcon_read_property(&page_number, this_ptr, SL("_page"), PH_NOISY_CC);
if (Z_TYPE_P(page_number) == IS_NULL) {
PHALCON_INIT_VAR(page_number);
ZVAL_LONG(page_number, 1);
}
PHALCON_INIT_VAR(zero);
ZVAL_LONG(zero, 0);
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
PHALCON_INIT_VAR(smaller);
is_smaller_function(smaller, show, zero TSRMLS_CC);
if (Z_TYPE_P(smaller) == IS_BOOL && Z_BVAL_P(smaller)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_paginator_exception_ce, "The start page number is zero or less");
return;
}
PHALCON_INIT_VAR(n);
phalcon_fast_count(n, items TSRMLS_CC);
PHALCON_INIT_VAR(page);
object_init(page);
PHALCON_INIT_VAR(last_show_page);
sub_function(last_show_page, page_number, one TSRMLS_CC);
PHALCON_INIT_VAR(start);
mul_function(start, show, last_show_page TSRMLS_CC);
PHALCON_INIT_VAR(last_page);
sub_function(last_page, n, one TSRMLS_CC);
PHALCON_INIT_VAR(possible_pages);
div_function(possible_pages, last_page, show TSRMLS_CC);
PHALCON_INIT_VAR(total_pages);
PHALCON_CALL_FUNC_PARAMS_1(total_pages, "ceil", possible_pages);
if (Z_TYPE_P(items) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_paginator_exception_ce, "Invalid data for paginator");
return;
}
if (Z_TYPE_P(page_number) == IS_NULL) {
PHALCON_INIT_VAR(page_number);
ZVAL_LONG(page_number, 0);
}
PHALCON_INIT_VAR(compare);
is_smaller_function(compare, start, zero TSRMLS_CC);
if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_paginator_exception_ce, "The start page number is zero or less");
return;
}
PHALCON_INIT_VAR(page_items);
array_init(page_items);
PHALCON_INIT_VAR(compare);
is_smaller_function(compare, zero, n TSRMLS_CC);
if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) {
PHALCON_INIT_VAR(compare);
is_smaller_or_equal_function(compare, start, n TSRMLS_CC);
if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(items, "seek", start, PH_NO_CHECK);
} else {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(items, "seek", one, PH_NO_CHECK);
PHALCON_INIT_VAR(page_number);
ZVAL_LONG(page_number, 1);
}
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 1);
ws_e435_0:
PHALCON_INIT_VAR(r0);
PHALCON_CALL_METHOD(r0, items, "valid", PH_NO_CHECK);
PHALCON_CPY_WRT(valid, r0);
if (Z_TYPE_P(valid) != IS_BOOL || (Z_TYPE_P(valid) == IS_BOOL && !Z_BVAL_P(valid))) {
goto we_e435_0;
}
PHALCON_INIT_VAR(current);
PHALCON_CALL_METHOD(current, items, "current", PH_NO_CHECK);
phalcon_array_append(&page_items, current, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(compare);
is_smaller_or_equal_function(compare, show, i TSRMLS_CC);
if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) {
goto we_e435_0;
}
PHALCON_SEPARATE(i);
increment_function(i);
goto ws_e435_0;
we_e435_0:
if(0){}
}
phalcon_update_property_zval(page, SL("items"), page_items TSRMLS_CC);
phalcon_update_property_long(page, SL("first"), 1 TSRMLS_CC);
PHALCON_INIT_VAR(maximum_pages);
phalcon_add_function(maximum_pages, start, show TSRMLS_CC);
PHALCON_INIT_VAR(compare);
is_smaller_function(compare, maximum_pages, n TSRMLS_CC);
if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) {
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 1);
PHALCON_INIT_VAR(next);
phalcon_add_function(next, page_number, t0 TSRMLS_CC);
} else {
PHALCON_INIT_VAR(compare);
is_equal_function(compare, maximum_pages, n TSRMLS_CC);
if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) {
PHALCON_CPY_WRT(next, n);
} else {
PHALCON_INIT_VAR(possible_pages);
div_function(possible_pages, n, show TSRMLS_CC);
PHALCON_INIT_VAR(additional_page);
phalcon_add_function(additional_page, possible_pages, one TSRMLS_CC);
PHALCON_INIT_VAR(next);
PHALCON_CALL_FUNC_PARAMS_1(next, "intval", additional_page);
}
}
PHALCON_INIT_VAR(compare);
is_smaller_function(compare, total_pages, next TSRMLS_CC);
if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) {
PHALCON_CPY_WRT(next, total_pages);
}
phalcon_update_property_zval(page, SL("next"), next TSRMLS_CC);
PHALCON_INIT_VAR(compare);
is_smaller_function(compare, one, page_number TSRMLS_CC);
if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) {
PHALCON_INIT_VAR(before);
sub_function(before, page_number, one TSRMLS_CC);
} else {
PHALCON_INIT_VAR(before);
ZVAL_LONG(before, 1);
}
phalcon_update_property_zval(page, SL("before"), before TSRMLS_CC);
phalcon_update_property_zval(page, SL("current"), page_number TSRMLS_CC);
PHALCON_INIT_VAR(remainder);
mod_function(remainder, n, show TSRMLS_CC);
PHALCON_INIT_VAR(possible_pages);
div_function(possible_pages, n, show TSRMLS_CC);
if (!phalcon_compare_strict_long(remainder, 0 TSRMLS_CC)) {
PHALCON_INIT_VAR(next);
phalcon_add_function(next, possible_pages, one TSRMLS_CC);
PHALCON_INIT_VAR(pages_total);
PHALCON_CALL_FUNC_PARAMS_1(pages_total, "intval", possible_pages);
} else {
PHALCON_CPY_WRT(pages_total, possible_pages);
}
phalcon_update_property_zval(page, SL("last"), pages_total TSRMLS_CC);
phalcon_update_property_zval(page, SL("total_pages"), pages_total TSRMLS_CC);
RETURN_CTOR(page);
}
PHP_METHOD(Phalcon_Tag_Select, select){
zval *parameters = NULL, *data = NULL, *params = NULL, *eol = NULL, *id = NULL, *value = NULL, *dummy_value = NULL;
zval *dummy_text = NULL, *code = NULL, *avalue = NULL, *key = NULL, *close_option = NULL;
zval *options = NULL, *using = NULL;
zval *a0 = NULL;
zval *t0 = NULL, *t1 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL, *r13 = NULL;
zval *p1[] = { NULL, NULL, NULL, NULL };
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", ¶meters, &data) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!data) {
PHALCON_INIT_VAR(data);
ZVAL_NULL(data);
}
if (Z_TYPE_P(parameters) != IS_ARRAY) {
PHALCON_INIT_VAR(a0);
array_init(a0);
phalcon_array_append(&a0, parameters, PHALCON_SEPARATE_PLZ TSRMLS_CC);
phalcon_array_append(&a0, data, PHALCON_SEPARATE_PLZ TSRMLS_CC);
PHALCON_CPY_WRT(params, a0);
} else {
PHALCON_CPY_WRT(params, parameters);
}
PHALCON_ALLOC_ZVAL_MM(t0);
zend_get_constant("PHP_EOL", strlen("PHP_EOL"), t0 TSRMLS_CC);
PHALCON_CPY_WRT(eol, t0);
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch_long(&r0, params, 0, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(id, r0);
eval_int = phalcon_array_isset_string(params, "value", strlen("value")+1);
if (!eval_int) {
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_STATIC_PARAMS_1(r1, "phalcon_tag", "getvalue", id);
PHALCON_CPY_WRT(value, r1);
} else {
PHALCON_ALLOC_ZVAL_MM(r2);
phalcon_array_fetch_string(&r2, params, "value", strlen("value"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(value, r2);
PHALCON_SEPARATE(params);
phalcon_array_unset_string(params, "value", strlen("value")+1);
}
eval_int = phalcon_array_isset_string(params, "dummyValue", strlen("dummyValue")+1);
if (!eval_int) {
PHALCON_INIT_VAR(dummy_value);
ZVAL_STRING(dummy_value, "", 1);
} else {
PHALCON_ALLOC_ZVAL_MM(r3);
phalcon_array_fetch_string(&r3, params, "dummyValue", strlen("dummyValue"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(dummy_value, r3);
PHALCON_SEPARATE(params);
phalcon_array_unset_string(params, "dummyValue", strlen("dummyValue")+1);
}
eval_int = phalcon_array_isset_string(params, "dummyText", strlen("dummyText")+1);
if (!eval_int) {
PHALCON_INIT_VAR(dummy_text);
ZVAL_STRING(dummy_text, "Choose...", 1);
} else {
PHALCON_ALLOC_ZVAL_MM(r4);
phalcon_array_fetch_string(&r4, params, "dummyText", strlen("dummyText"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(dummy_text, r4);
PHALCON_SEPARATE(params);
phalcon_array_unset_string(params, "dummyText", strlen("dummyText")+1);
}
PHALCON_ALLOC_ZVAL_MM(r5);
PHALCON_CONCAT_SVSVS(r5, "<select id=\"", id, "\" name=\"", id, "\"");
PHALCON_CPY_WRT(code, r5);
if (Z_TYPE_P(params) == IS_ARRAY) {
if (phalcon_valid_foreach(params TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(params);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_9c31_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_9c31_0;
} else {
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
}
PHALCON_INIT_VAR(avalue);
ZVAL_ZVAL(avalue, *hd, 1, 0);
if (Z_TYPE_P(key) != IS_LONG) {
if (Z_TYPE_P(avalue) != IS_ARRAY) {
PHALCON_INIT_VAR(r6);
PHALCON_CONCAT_SVSVS(r6, " ", key, "=\"", avalue, "\"");
phalcon_concat_self(&code, r6 TSRMLS_CC);
}
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_9c31_0;
fee_9c31_0:
if(0){}
} else {
return;
}
}
PHALCON_ALLOC_ZVAL_MM(r7);
PHALCON_CONCAT_SV(r7, ">", eol);
phalcon_concat_self(&code, r7 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r8);
PHALCON_CONCAT_SV(r8, "</option>", eol);
PHALCON_CPY_WRT(close_option, r8);
eval_int = phalcon_array_isset_string(params, "useDummy", strlen("useDummy")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r9);
PHALCON_CONCAT_SVSVV(r9, "\t<option value=\"", dummy_value, "\">", dummy_text, close_option);
phalcon_concat_self(&code, r9 TSRMLS_CC);
}
eval_int = phalcon_array_isset_long(params, 1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r10);
phalcon_array_fetch_long(&r10, params, 1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(options, r10);
} else {
PHALCON_CPY_WRT(options, data);
}
if (Z_TYPE_P(options) == IS_OBJECT) {
eval_int = phalcon_array_isset_string(params, "using", strlen("using")+1);
if (!eval_int) {
PHALCON_THROW_EXCEPTION_STR(phalcon_tag_exception_ce, "The 'using' parameter is required");
return;
} else {
PHALCON_ALLOC_ZVAL_MM(r11);
phalcon_array_fetch_string(&r11, params, "using", strlen("using"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(using, r11);
if (Z_TYPE_P(using) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_tag_exception_ce, "The 'using' parameter should be an Array");
return;
}
}
PHALCON_ALLOC_ZVAL_MM(r12);
p1[0] = options;
p1[1] = using;
p1[2] = value;
p1[3] = close_option;
PHALCON_CALL_SELF_PARAMS(r12, this_ptr, "_optionsfromresultset", 4, p1);
phalcon_concat_self(&code, r12 TSRMLS_CC);
} else {
/**
* Builds a HTML input[type="submit"] tag
*
* <code>echo Phalcon\Tag::submitButton("Save")</code>
*
* @param array $params
* @return string
*/
PHP_METHOD(Phalcon_Tag, submitButton){
zval *parameters = NULL, *params = NULL, *value = NULL, *code = NULL, *avalue = NULL;
zval *key = NULL, *attribute = NULL;
zval *t0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", ¶meters) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(parameters) != IS_ARRAY) {
PHALCON_INIT_VAR(params);
array_init(params);
phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_CPY_WRT(params, parameters);
}
eval_int = phalcon_array_isset_string(params, SL("value")+1);
if (eval_int) {
PHALCON_INIT_VAR(value);
phalcon_array_fetch_string(&value, params, SL("value"), PH_NOISY_CC);
PHALCON_SEPARATE(params);
phalcon_array_unset_string(params, SL("value")+1);
} else {
eval_int = phalcon_array_isset_long(params, 0);
if (eval_int) {
PHALCON_INIT_VAR(value);
phalcon_array_fetch_long(&value, params, 0, PH_NOISY_CC);
} else {
PHALCON_INIT_VAR(value);
ZVAL_STRING(value, "", 1);
}
}
PHALCON_INIT_VAR(code);
PHALCON_CONCAT_SVS(code, "<input type=\"submit\" value=\"", value, "\" ");
if (!phalcon_valid_foreach(params TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(params);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_9b93_3:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_9b93_3;
}
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_INIT_VAR(avalue);
ZVAL_ZVAL(avalue, *hd, 1, 0);
if (Z_TYPE_P(key) != IS_LONG) {
PHALCON_INIT_VAR(attribute);
PHALCON_CONCAT_VSVS(attribute, key, "=\"", avalue, "\" ");
phalcon_concat_self(&code, attribute TSRMLS_CC);
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_9b93_3;
fee_9b93_3:
PHALCON_INIT_VAR(t0);
ZVAL_STRING(t0, " />", 1);
phalcon_concat_self(&code, t0 TSRMLS_CC);
RETURN_CTOR(code);
}
/**
* Builds a LINK[rel="stylesheet"] tag
*
* <code>
* echo Phalcon\Tag::stylesheetLink("http://fonts.googleapis.com/css?family=Rosario", false);
* echo Phalcon\Tag::stylesheetLink("css/style.css");
* </code>
*
* @param array $parameters
* @param boolean $local
* @return string
*/
PHP_METHOD(Phalcon_Tag, stylesheetLink){
zval *parameters = NULL, *local = NULL, *params = NULL, *first_param = NULL;
zval *url = NULL, *href = NULL, *code = NULL, *value = NULL, *key = NULL, *attribute = NULL;
zval *r0 = NULL;
zval *t0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zz", ¶meters, &local) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!parameters) {
PHALCON_ALLOC_ZVAL_MM(parameters);
ZVAL_NULL(parameters);
}
if (!local) {
PHALCON_ALLOC_ZVAL_MM(local);
ZVAL_BOOL(local, 1);
} else {
PHALCON_SEPARATE_PARAM(local);
}
if (Z_TYPE_P(parameters) != IS_ARRAY) {
PHALCON_INIT_VAR(params);
array_init(params);
phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(¶ms, local, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_CPY_WRT(params, parameters);
}
eval_int = phalcon_array_isset_string(params, SL("href")+1);
if (!eval_int) {
eval_int = phalcon_array_isset_long(params, 0);
if (eval_int) {
PHALCON_INIT_VAR(first_param);
phalcon_array_fetch_long(&first_param, params, 0, PH_NOISY_CC);
phalcon_array_update_string(¶ms, SL("href"), &first_param, PH_COPY | PH_SEPARATE TSRMLS_CC);
} else {
phalcon_array_update_string_string(¶ms, SL("href"), SL(""), PH_SEPARATE TSRMLS_CC);
}
}
PHALCON_INIT_VAR(local);
ZVAL_STRING(local, "", 1);
eval_int = phalcon_array_isset_long(params, 1);
if (eval_int) {
PHALCON_INIT_VAR(local);
phalcon_array_fetch_long(&local, params, 1, PH_NOISY_CC);
} else {
eval_int = phalcon_array_isset_string(params, SL("local")+1);
if (eval_int) {
PHALCON_INIT_VAR(local);
phalcon_array_fetch_string(&local, params, SL("local"), PH_NOISY_CC);
PHALCON_SEPARATE(params);
phalcon_array_unset_string(params, SL("local")+1);
}
}
eval_int = phalcon_array_isset_string(params, SL("type")+1);
if (!eval_int) {
phalcon_array_update_string_string(¶ms, SL("type"), SL("text/css"), PH_SEPARATE TSRMLS_CC);
}
if (zend_is_true(local)) {
PHALCON_INIT_VAR(url);
PHALCON_CALL_SELF(url, this_ptr, "geturlservice");
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch_string(&r0, params, SL("href"), PH_NOISY_CC);
PHALCON_INIT_VAR(href);
PHALCON_CALL_METHOD_PARAMS_1(href, url, "get", r0, PH_NO_CHECK);
phalcon_array_update_string(¶ms, SL("href"), &href, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(code);
ZVAL_STRING(code, "<link rel=\"stylesheet\"", 1);
if (!phalcon_valid_foreach(params TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(params);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_9b93_6:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_9b93_6;
}
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
if (Z_TYPE_P(key) != IS_LONG) {
PHALCON_INIT_VAR(attribute);
PHALCON_CONCAT_SVSVS(attribute, " ", key, "=\"", value, "\"");
phalcon_concat_self(&code, attribute TSRMLS_CC);
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_9b93_6;
fee_9b93_6:
PHALCON_INIT_VAR(t0);
ZVAL_STRING(t0, "/>", 1);
phalcon_concat_self(&code, t0 TSRMLS_CC);
RETURN_CTOR(code);
}
/**
* Handles routing information received from the rewrite engine
*
* @param string $uri
*/
PHP_METHOD(Phalcon_Mvc_Router, handle){
zval *uri = NULL, *real_uri = NULL, *route_found = NULL, *parts = NULL, *params = NULL;
zval *matches = NULL, *route = NULL, *position = NULL, *part = NULL, *str_params = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL, *r9 = NULL;
zval *c0 = NULL, *c1 = NULL;
zval *a0 = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &uri) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!uri) {
PHALCON_ALLOC_ZVAL_MM(uri);
ZVAL_NULL(uri);
}
if (!zend_is_true(uri)) {
PHALCON_INIT_VAR(real_uri);
PHALCON_CALL_METHOD(real_uri, this_ptr, "_getrewriteuri", PH_NO_CHECK);
} else {
PHALCON_CPY_WRT(real_uri, uri);
}
PHALCON_INIT_VAR(route_found);
ZVAL_BOOL(route_found, 0);
PHALCON_INIT_VAR(parts);
array_init(parts);
PHALCON_INIT_VAR(params);
array_init(params);
PHALCON_INIT_VAR(matches);
array_init(matches);
phalcon_update_property_bool(this_ptr, SL("_wasMatched"), 0 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_routes"), PH_NOISY_CC);
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_FUNC_PARAMS_1(r0, "array_reverse", t0);
if (!phalcon_valid_foreach(r0 TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(r0);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_c9ff_1:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_c9ff_1;
}
PHALCON_INIT_VAR(route);
ZVAL_ZVAL(route, *hd, 1, 0);
PHALCON_INIT_VAR(parts);
phalcon_array_fetch_string(&parts, route, SL("paths"), PH_NOISY_CC);
PHALCON_INIT_VAR(r1);
phalcon_array_fetch_string(&r1, route, SL("pattern"), PH_NOISY_CC);
Z_SET_ISREF_P(matches);
PHALCON_INIT_VAR(r2);
PHALCON_CALL_FUNC_PARAMS_3(r2, "preg_match", r1, real_uri, matches);
Z_UNSET_ISREF_P(matches);
if (zend_is_true(r2)) {
PHALCON_INIT_VAR(r3);
phalcon_array_fetch_string(&r3, route, SL("paths"), PH_NOISY_CC);
if (!phalcon_valid_foreach(r3 TSRMLS_CC)) {
return;
}
ah1 = Z_ARRVAL_P(r3);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
fes_c9ff_2:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_c9ff_2;
}
PHALCON_INIT_VAR(part);
PHALCON_GET_FOREACH_KEY(part, ah1, hp1);
PHALCON_INIT_VAR(position);
ZVAL_ZVAL(position, *hd, 1, 0);
eval_int = phalcon_array_isset(matches, position);
if (eval_int) {
PHALCON_INIT_VAR(r4);
phalcon_array_fetch(&r4, matches, position, PH_NOISY_CC);
phalcon_array_update_zval(&parts, part, &r4, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_c9ff_2;
fee_c9ff_2:
if(0){}
phalcon_update_property_zval(this_ptr, SL("_matches"), matches TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_currentRoute"), route TSRMLS_CC);
PHALCON_INIT_VAR(route_found);
ZVAL_BOOL(route_found, 1);
goto fee_c9ff_1;
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_c9ff_1;
fee_c9ff_1:
if(0){}
if (zend_is_true(route_found)) {
eval_int = phalcon_array_isset_string(parts, SL("module")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r5);
phalcon_array_fetch_string(&r5, parts, SL("module"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_module"), r5 TSRMLS_CC);
PHALCON_SEPARATE(parts);
phalcon_array_unset_string(parts, SL("module")+1);
} else {
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, SL("_defaultModule"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_module"), t1 TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(parts, SL("controller")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r6);
phalcon_array_fetch_string(&r6, parts, SL("controller"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_controller"), r6 TSRMLS_CC);
PHALCON_SEPARATE(parts);
phalcon_array_unset_string(parts, SL("controller")+1);
} else {
phalcon_update_property_null(this_ptr, SL("_controller") TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(parts, SL("action")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r7);
phalcon_array_fetch_string(&r7, parts, SL("action"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_action"), r7 TSRMLS_CC);
PHALCON_SEPARATE(parts);
phalcon_array_unset_string(parts, SL("action")+1);
} else {
phalcon_update_property_null(this_ptr, SL("_action") TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(parts, SL("params")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r8);
phalcon_array_fetch_string(&r8, parts, SL("params"), PH_NOISY_CC);
PHALCON_INIT_VAR(c0);
ZVAL_LONG(c0, 1);
PHALCON_INIT_VAR(str_params);
PHALCON_CALL_FUNC_PARAMS_2(str_params, "substr", r8, c0);
if (zend_is_true(str_params)) {
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, "/", 1);
PHALCON_INIT_VAR(params);
phalcon_fast_explode(params, c1, str_params TSRMLS_CC);
}
PHALCON_SEPARATE(parts);
phalcon_array_unset_string(parts, SL("params")+1);
}
PHALCON_ALLOC_ZVAL_MM(r9);
PHALCON_CALL_FUNC_PARAMS_2(r9, "array_merge", params, parts);
phalcon_update_property_zval(this_ptr, SL("_params"), r9 TSRMLS_CC);
phalcon_update_property_bool(this_ptr, SL("_wasMatched"), 1 TSRMLS_CC);
} else {
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, SL("_defaultModule"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_module"), t2 TSRMLS_CC);
phalcon_update_property_null(this_ptr, SL("_controller") TSRMLS_CC);
phalcon_update_property_null(this_ptr, SL("_action") TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(a0);
array_init(a0);
phalcon_update_property_zval(this_ptr, SL("_params"), a0 TSRMLS_CC);
phalcon_update_property_bool(this_ptr, SL("_wasMatched"), 0 TSRMLS_CC);
}
PHALCON_MM_RESTORE();
}
/**
* Rebuild the list of access from the inherit lists
*
*/
PHP_METHOD(Phalcon_Acl_Adapter_Memory, _rebuildAccessList){
zval *roles, *number_roles, *pow_roles, *two, *middle_roles;
zval *middle, *roles_names, *roles_inherits;
zval *changed = NULL, *i, *internal_access = NULL, *one = NULL, *role_name = NULL;
zval *role_inherit = NULL, *inherit_internal = NULL, *access = NULL;
zval *resource_name = NULL, *value = NULL, *name = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL;
HashTable *ah0, *ah1, *ah2, *ah3;
HashPosition hp0, hp1, hp2, hp3;
zval **hd;
PHALCON_MM_GROW();
PHALCON_OBS_VAR(roles);
phalcon_read_property(&roles, this_ptr, SL("_roles"), PH_NOISY_CC);
PHALCON_INIT_VAR(number_roles);
phalcon_fast_count(number_roles, roles TSRMLS_CC);
PHALCON_INIT_VAR(pow_roles);
Z_LVAL_P(pow_roles) = Z_LVAL_P(number_roles) * Z_LVAL_P(number_roles);
PHALCON_INIT_VAR(two);
ZVAL_LONG(two, 2);
PHALCON_INIT_VAR(middle_roles);
div_function(middle_roles, pow_roles, two TSRMLS_CC);
PHALCON_INIT_VAR(middle);
PHALCON_CALL_FUNC_PARAMS_1(middle, "ceil", middle_roles);
PHALCON_OBS_VAR(roles_names);
phalcon_read_property(&roles_names, this_ptr, SL("_rolesNames"), PH_NOISY_CC);
PHALCON_OBS_VAR(roles_inherits);
phalcon_read_property(&roles_inherits, this_ptr, SL("_roleInherits"), PH_NOISY_CC);
PHALCON_INIT_VAR(changed);
ZVAL_BOOL(changed, 1);
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 0);
while (1) {
PHALCON_INIT_NVAR(r0);
is_smaller_or_equal_function(r0, i, middle TSRMLS_CC);
if (!zend_is_true(r0)) {
break;
}
PHALCON_OBS_NVAR(internal_access);
phalcon_read_property(&internal_access, this_ptr, SL("_access"), PH_NOISY_CC);
if (!phalcon_is_iterable(roles_names, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(role_name, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(one);
if (phalcon_array_isset(roles_inherits, role_name)) {
PHALCON_OBS_NVAR(r1);
phalcon_array_fetch(&r1, roles_inherits, role_name, PH_NOISY_CC);
if (!phalcon_is_iterable(r1, &ah1, &hp1, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(role_inherit);
if (phalcon_array_isset(internal_access, role_inherit)) {
PHALCON_OBS_NVAR(inherit_internal);
phalcon_array_fetch(&inherit_internal, internal_access, role_inherit, PH_NOISY_CC);
if (!phalcon_is_iterable(inherit_internal, &ah2, &hp2, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(resource_name, ah2, hp2);
PHALCON_GET_FOREACH_VALUE(access);
if (!phalcon_is_iterable(access, &ah3, &hp3, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(name, ah3, hp3);
PHALCON_GET_FOREACH_VALUE(value);
if (phalcon_array_isset(internal_access, role_name)) {
PHALCON_OBS_NVAR(r2);
phalcon_array_fetch(&r2, internal_access, role_name, PH_NOISY_CC);
if (phalcon_array_isset(r2, resource_name)) {
PHALCON_OBS_NVAR(r3);
phalcon_array_fetch(&r3, internal_access, role_name, PH_NOISY_CC);
PHALCON_OBS_NVAR(r4);
phalcon_array_fetch(&r4, r3, resource_name, PH_NOISY_CC);
if (phalcon_array_isset(r4, name)) {
zend_hash_move_forward_ex(ah3, &hp3);
continue;
}
}
}
phalcon_array_update_zval_zval_zval_multi_3(&internal_access, role_name, resource_name, name, &value, 0 TSRMLS_CC);
PHALCON_INIT_NVAR(changed);
ZVAL_BOOL(changed, 1);
zend_hash_move_forward_ex(ah3, &hp3);
}
zend_hash_move_forward_ex(ah2, &hp2);
}
}
zend_hash_move_forward_ex(ah1, &hp1);
}
}
zend_hash_move_forward_ex(ah0, &hp0);
}
if (zend_is_true(changed)) {
phalcon_update_property_zval(this_ptr, SL("_access"), internal_access TSRMLS_CC);
}
PHALCON_SEPARATE(i);
increment_function(i);
}
PHALCON_MM_RESTORE();
}
/**
* Sends SQL statements to the database server returning the success state.
* Use this method only when the SQL statement sent to the server don't return any row
*
* //Inserting data
* $success = $connection->execute("INSERT INTO robots VALUES (1, 'Astro Boy')");
* $success = $connection->execute("INSERT INTO robots VALUES (?, ?)", array(1, 'Astro Boy'));
*
* @param string $sqlStatement
* @param array $placeholders
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, execute){
zval *sql_statement = NULL, *placeholders = NULL, *events_manager = NULL;
zval *status = NULL, *pdo = NULL, *number_placeholders = NULL, *n = NULL, *statement = NULL;
zval *value = NULL, *success = NULL, *affected_rows = NULL, *error_info = NULL;
zval *error_message = NULL, *exception_message = NULL, *error_code = NULL;
zval *exception = NULL;
zval *c0 = NULL, *c1 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &sql_statement, &placeholders) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!placeholders) {
PHALCON_INIT_VAR(placeholders);
array_init(placeholders);
}
PHALCON_INIT_VAR(events_manager);
phalcon_read_property(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
if (zend_is_true(events_manager)) {
phalcon_update_property_zval(this_ptr, SL("_sqlStatement"), sql_statement TSRMLS_CC);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "db:beforeQuery", 1);
PHALCON_INIT_VAR(status);
PHALCON_CALL_METHOD_PARAMS_2(status, events_manager, "fire", c0, this_ptr, PH_NO_CHECK);
if (Z_TYPE_P(status) == IS_BOOL && !Z_BVAL_P(status)) {
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
}
PHALCON_INIT_VAR(pdo);
phalcon_read_property(&pdo, this_ptr, SL("_pdo"), PH_NOISY_CC);
PHALCON_INIT_VAR(number_placeholders);
phalcon_fast_count(number_placeholders, placeholders TSRMLS_CC);
if (zend_is_true(number_placeholders)) {
PHALCON_INIT_VAR(n);
ZVAL_LONG(n, 1);
PHALCON_INIT_VAR(statement);
PHALCON_CALL_METHOD_PARAMS_1(statement, pdo, "prepare", sql_statement, PH_NO_CHECK);
if (!phalcon_valid_foreach(placeholders TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(placeholders);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_7f5d_1:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_7f5d_1;
}
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(statement, "bindparam", n, value, PH_NO_CHECK);
PHALCON_SEPARATE(n);
increment_function(n);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_7f5d_1;
fee_7f5d_1:
PHALCON_INIT_VAR(success);
PHALCON_CALL_METHOD(success, statement, "execute", PH_NO_CHECK);
PHALCON_INIT_VAR(affected_rows);
PHALCON_CALL_METHOD(affected_rows, statement, "rowcount", PH_NO_CHECK);
} else {
PHALCON_INIT_VAR(success);
ZVAL_BOOL(success, 1);
PHALCON_INIT_VAR(affected_rows);
PHALCON_CALL_METHOD_PARAMS_1(affected_rows, pdo, "exec", sql_statement, PH_NO_CHECK);
}
if (zend_is_true(success)) {
if (Z_TYPE_P(affected_rows) == IS_LONG) {
phalcon_update_property_zval(this_ptr, SL("_affectedRows"), affected_rows TSRMLS_CC);
if (zend_is_true(events_manager)) {
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, "db:afterQuery", 1);
PHALCON_INIT_VAR(status);
PHALCON_CALL_METHOD_PARAMS_2(status, events_manager, "fire", c1, this_ptr, PH_NO_CHECK);
if (Z_TYPE_P(status) == IS_BOOL && !Z_BVAL_P(status)) {
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
}
PHALCON_INIT_VAR(error_info);
PHALCON_CALL_METHOD(error_info, pdo, "errorinfo", PH_NO_CHECK);
PHALCON_INIT_VAR(error_message);
phalcon_array_fetch_long(&error_message, error_info, 2, PH_NOISY_CC);
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_VSV(exception_message, error_message, " when executing ", sql_statement);
PHALCON_INIT_VAR(error_code);
phalcon_array_fetch_long(&error_code, error_info, 1, PH_NOISY_CC);
PHALCON_INIT_VAR(exception);
object_init_ex(exception, phalcon_db_exception_ce);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(exception, "__construct", exception_message, error_code, PH_CHECK);
phalcon_throw_exception(exception TSRMLS_CC);
return;
}
/**
* Get the conditions of query
*
* @return string $query
*/
PHP_METHOD(Phalcon_Model_Query, getConditions){
zval *controller_front = NULL, *model_manager = NULL, *model_name = NULL;
zval *entity = NULL, *meta_data = NULL, *attributes = NULL, *numeric_types = NULL;
zval *i = NULL, *parameters = NULL, *conditions = NULL, *value = NULL, *param = NULL;
zval *condition = NULL, *index = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL, *t6 = NULL;
zval *t7 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL, *r13 = NULL;
zval *r14 = NULL, *r15 = NULL, *r16 = NULL, *r17 = NULL, *r18 = NULL;
zval *i0 = NULL;
zval *a0 = NULL, *a1 = NULL;
zval *c0 = NULL;
HashTable *ah0, *ah1, *ah2;
HashPosition hp0, hp1, hp2;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_manager", sizeof("_manager")-1, PHALCON_NOISY TSRMLS_CC);
if (!zend_is_true(t0)) {
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_STATIC(r0, "phalcon_controller_front", "getinstance");
PHALCON_CPY_WRT(controller_front, r0);
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_METHOD(r1, controller_front, "getmodelcomponent", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(model_manager, r1);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(this_ptr, "setmanager", model_manager, PHALCON_NO_CHECK);
} else {
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_manager", sizeof("_manager")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(model_manager, t1);
}
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, "_models", sizeof("_models")-1, PHALCON_NOISY TSRMLS_CC);
if (phalcon_valid_foreach(t2 TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(t2);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_a355_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_a355_0;
}
PHALCON_INIT_VAR(model_name);
ZVAL_ZVAL(model_name, *hd, 1, 0);
PHALCON_INIT_VAR(r2);
PHALCON_CALL_METHOD_PARAMS_1(r2, model_manager, "getmodel", model_name, PHALCON_NO_CHECK);
PHALCON_CPY_WRT(entity, r2);
if (!zend_is_true(entity)) {
PHALCON_INIT_VAR(i0);
object_init_ex(i0, phalcon_model_exception_ce);
PHALCON_INIT_VAR(r3);
PHALCON_CONCAT_BOTH(r3, "The model ", model_name, " does not exist");
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i0, "__construct", r3, PHALCON_CHECK);
phalcon_throw_exception(i0 TSRMLS_CC);
return;
}
PHALCON_INIT_VAR(r4);
PHALCON_CALL_METHOD(r4, model_manager, "getmetadata", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(meta_data, r4);
PHALCON_INIT_VAR(r5);
PHALCON_CALL_METHOD_PARAMS_1(r5, meta_data, "getattributes", entity, PHALCON_NO_CHECK);
PHALCON_CPY_WRT(attributes, r5);
PHALCON_INIT_VAR(r6);
PHALCON_CALL_METHOD_PARAMS_1(r6, meta_data, "getdatatypesnumeric", entity, PHALCON_NO_CHECK);
PHALCON_CPY_WRT(numeric_types, r6);
PHALCON_INIT_VAR(t3);
phalcon_read_property(&t3, this_ptr, "_data", sizeof("_data")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(r7);
phalcon_fast_count(r7, t3 TSRMLS_CC);
if (zend_is_true(r7)) {
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 0);
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(parameters, a0);
PHALCON_INIT_VAR(a1);
array_init(a1);
PHALCON_CPY_WRT(conditions, a1);
PHALCON_INIT_VAR(t4);
phalcon_read_property(&t4, this_ptr, "_data", sizeof("_data")-1, PHALCON_NOISY TSRMLS_CC);
if (phalcon_valid_foreach(t4 TSRMLS_CC)) {
ah1 = Z_ARRVAL_P(t4);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
fes_a355_1:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_a355_1;
} else {
PHALCON_INIT_VAR(param);
PHALCON_GET_FOREACH_KEY(param, ah1, hp1);
}
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
PHALCON_INIT_VAR(r8);
PHALCON_CALL_FUNC_PARAMS_2(r8, "in_array", param, attributes, 0x03E);
if (zend_is_true(r8)) {
PHALCON_INIT_VAR(t5);
ZVAL_STRING(t5, "", 1);
PHALCON_INIT_VAR(r9);
is_not_identical_function(r9, t5, value TSRMLS_CC);
PHALCON_INIT_VAR(r11);
PHALCON_CALL_FUNC_PARAMS_1(r11, "is_null", value, 0x041);
PHALCON_INIT_VAR(r10);
boolean_not_function(r10, r11 TSRMLS_CC);
PHALCON_INIT_VAR(r12);
phalcon_and_function(r12, r9, r10);
if (zend_is_true(r12)) {
if (!PHALCON_COMPARE_STRING(value, "@")) {
eval_int = phalcon_array_isset(numeric_types, param);
if (eval_int) {
PHALCON_INIT_VAR(r13);
PHALCON_CONCAT_VBOTH(r13, param, " = ?", i);
PHALCON_CPY_WRT(condition, r13);
phalcon_array_update(¶meters, i, &value, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
} else {
PHALCON_INIT_VAR(r14);
PHALCON_CONCAT_VBOTH(r14, param, " LIKE ?", i);
PHALCON_CPY_WRT(condition, r14);
PHALCON_INIT_VAR(r15);
PHALCON_CONCAT_BOTH(r15, "%", value, "%");
phalcon_array_update(¶meters, i, &r15, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
}
phalcon_array_append(&conditions, condition, PHALCON_SEPARATE_PLZ TSRMLS_CC);
}
}
}
PHALCON_SEPARATE(i);
increment_function(i);
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_a355_1;
fee_a355_1:
if(0){}
} else {
return;
}
} else {
PHALCON_INIT_VAR(t6);
phalcon_read_property(&t6, this_ptr, "_parameters", sizeof("_parameters")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(parameters, t6);
PHALCON_INIT_VAR(t7);
phalcon_read_property(&t7, this_ptr, "_conditions", sizeof("_conditions")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(conditions, t7);
}
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, " AND ", 1);
PHALCON_INIT_VAR(r16);
phalcon_fast_join(r16, c0, conditions TSRMLS_CC);
PHALCON_CPY_WRT(conditions, r16);
if (phalcon_valid_foreach(parameters TSRMLS_CC)) {
ah2 = Z_ARRVAL_P(parameters);
zend_hash_internal_pointer_reset_ex(ah2, &hp2);
fes_a355_2:
if(zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) != SUCCESS){
goto fee_a355_2;
} else {
PHALCON_INIT_VAR(index);
PHALCON_GET_FOREACH_KEY(index, ah2, hp2);
}
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
PHALCON_INIT_VAR(r17);
PHALCON_INIT_VAR(r18);
PHALCON_CONCAT_LEFT(r18, "?", index);
PHALCON_CALL_FUNC_PARAMS_3(r17, "str_replace", r18, value, conditions, 0x003);
PHALCON_CPY_WRT(conditions, r17);
zend_hash_move_forward_ex(ah2, &hp2);
goto fes_a355_2;
fee_a355_2:
if(0){}
} else {
return;
}
if (PHALCON_COMPARE_STRING(conditions, "")) {
PHALCON_INIT_VAR(conditions);
ZVAL_STRING(conditions, "1=1", 1);
}
PHALCON_RETURN_CHECK_CTOR(conditions);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_a355_0;
fee_a355_0:
if(0){}
} else {
return;
}
PHALCON_MM_RESTORE();
}
/**
* Generates a SELECT tag
*
* @param array $parameters
* @param array $data
*/
PHP_METHOD(Phalcon_Tag_Select, selectField){
zval *parameters, *data = NULL, *params = NULL, *eol, *id = NULL, *name, *value = NULL;
zval *use_empty = NULL, *empty_value = NULL, *empty_text = NULL, *code;
zval *avalue = NULL, *key = NULL, *close_option, *options = NULL, *using;
zval *resultset_options, *array_options;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", ¶meters, &data) == FAILURE) {
RETURN_MM_NULL();
}
if (!data) {
PHALCON_INIT_VAR(data);
}
if (Z_TYPE_P(parameters) != IS_ARRAY) {
PHALCON_INIT_VAR(params);
array_init_size(params, 2);
phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(¶ms, data, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_CPY_WRT(params, parameters);
}
PHALCON_INIT_VAR(eol);
zend_get_constant(SL("PHP_EOL"), eol TSRMLS_CC);
if (!phalcon_array_isset_long(params, 0)) {
PHALCON_OBS_VAR(id);
phalcon_array_fetch_string(&id, params, SL("id"), PH_NOISY_CC);
phalcon_array_update_long(¶ms, 0, &id, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
PHALCON_OBS_NVAR(id);
phalcon_array_fetch_long(&id, params, 0, PH_NOISY_CC);
if (!phalcon_array_isset_string(params, SS("name"))) {
phalcon_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_OBS_VAR(name);
phalcon_array_fetch_string(&name, params, SL("name"), PH_NOISY_CC);
if (!zend_is_true(name)) {
phalcon_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
}
if (!phalcon_array_isset_string(params, SS("id"))) {
phalcon_array_update_string(¶ms, SL("id"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
if (!phalcon_array_isset_string(params, SS("value"))) {
PHALCON_INIT_VAR(value);
PHALCON_CALL_STATIC_PARAMS_2(value, "phalcon\\tag", "getvalue", id, params);
} else {
PHALCON_OBS_NVAR(value);
phalcon_array_fetch_string(&value, params, SL("value"), PH_NOISY_CC);
PHALCON_SEPARATE(params);
phalcon_array_unset_string(params, SS("value"));
}
PHALCON_INIT_VAR(use_empty);
ZVAL_BOOL(use_empty, 0);
if (phalcon_array_isset_string(params, SS("useEmpty"))) {
if (!phalcon_array_isset_string(params, SS("emptyValue"))) {
PHALCON_INIT_VAR(empty_value);
ZVAL_STRING(empty_value, "", 1);
} else {
PHALCON_OBS_NVAR(empty_value);
phalcon_array_fetch_string(&empty_value, params, SL("emptyValue"), PH_NOISY_CC);
PHALCON_SEPARATE(params);
phalcon_array_unset_string(params, SS("emptyValue"));
}
if (!phalcon_array_isset_string(params, SS("emptyText"))) {
PHALCON_INIT_VAR(empty_text);
ZVAL_STRING(empty_text, "Choose...", 1);
} else {
PHALCON_OBS_NVAR(empty_text);
phalcon_array_fetch_string(&empty_text, params, SL("emptyText"), PH_NOISY_CC);
PHALCON_SEPARATE(params);
phalcon_array_unset_string(params, SS("emptyText"));
}
PHALCON_OBS_NVAR(use_empty);
phalcon_array_fetch_string(&use_empty, params, SL("useEmpty"), PH_NOISY_CC);
PHALCON_SEPARATE(params);
phalcon_array_unset_string(params, SS("useEmpty"));
}
PHALCON_INIT_VAR(code);
ZVAL_STRING(code, "<select", 1);
if (Z_TYPE_P(params) == IS_ARRAY) {
if (!phalcon_is_iterable(params, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(avalue);
if (Z_TYPE_P(key) != IS_LONG) {
if (Z_TYPE_P(avalue) != IS_ARRAY) {
PHALCON_SCONCAT_SVSVS(code, " ", key, "=\"", avalue, "\"");
}
}
zend_hash_move_forward_ex(ah0, &hp0);
}
}
PHALCON_SCONCAT_SV(code, ">", eol);
PHALCON_INIT_VAR(close_option);
PHALCON_CONCAT_SV(close_option, "</option>", eol);
if (zend_is_true(use_empty)) {
/**
* Create an empty value
*/
PHALCON_SCONCAT_SVSVV(code, "\t<option value=\"", empty_value, "\">", empty_text, close_option);
PHALCON_SEPARATE(params);
phalcon_array_unset_string(params, SS("useEmpty"));
}
if (phalcon_array_isset_long(params, 1)) {
PHALCON_OBS_VAR(options);
phalcon_array_fetch_long(&options, params, 1, PH_NOISY_CC);
} else {
PHALCON_CPY_WRT(options, data);
}
if (Z_TYPE_P(options) == IS_OBJECT) {
/**
* The options is a resultset
*/
if (!phalcon_array_isset_string(params, SS("using"))) {
PHALCON_THROW_EXCEPTION_STR(phalcon_tag_exception_ce, "The 'using' parameter is required");
return;
} else {
PHALCON_OBS_VAR(using);
phalcon_array_fetch_string(&using, params, SL("using"), PH_NOISY_CC);
if (Z_TYPE_P(using) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_tag_exception_ce, "The 'using' parameter should be an Array");
return;
}
}
/**
* Create the SELECT's option from a resultset
*/
PHALCON_INIT_VAR(resultset_options);
PHALCON_CALL_SELF_PARAMS_4(resultset_options, this_ptr, "_optionsfromresultset", options, using, value, close_option);
phalcon_concat_self(&code, resultset_options TSRMLS_CC);
} else {
if (Z_TYPE_P(options) == IS_ARRAY) {
/**
* Process a request header and return the one with best quality
*
* @param array $qualityParts
* @param string $name
* @return string
*/
PHP_METHOD(Phalcon_Http_Request, _getBestQuality){
zval *quality_parts = NULL, *name = NULL, *i = NULL, *quality = NULL, *selected_name = NULL;
zval *accept = NULL, *accept_quality = NULL;
zval *r0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &quality_parts, &name) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 0);
PHALCON_INIT_VAR(quality);
ZVAL_LONG(quality, 0);
PHALCON_INIT_VAR(selected_name);
ZVAL_STRING(selected_name, "", 1);
if (!phalcon_valid_foreach(quality_parts TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(quality_parts);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_ac06_3:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_ac06_3;
}
PHALCON_INIT_VAR(accept);
ZVAL_ZVAL(accept, *hd, 1, 0);
if (phalcon_compare_strict_long(i, 0 TSRMLS_CC)) {
PHALCON_INIT_VAR(quality);
phalcon_array_fetch_string(&quality, accept, SL("quality"), PH_NOISY_CC);
PHALCON_INIT_VAR(selected_name);
phalcon_array_fetch(&selected_name, accept, name, PH_NOISY_CC);
} else {
PHALCON_INIT_VAR(accept_quality);
phalcon_array_fetch_string(&accept_quality, accept, SL("quality"), PH_NOISY_CC);
PHALCON_INIT_VAR(r0);
is_smaller_function(r0, quality, accept_quality TSRMLS_CC);
if (zend_is_true(r0)) {
PHALCON_CPY_WRT(quality, accept_quality);
PHALCON_INIT_VAR(selected_name);
phalcon_array_fetch(&selected_name, accept, name, PH_NOISY_CC);
}
}
PHALCON_SEPARATE(i);
increment_function(i);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_ac06_3;
fee_ac06_3:
RETURN_CCTOR(selected_name);
}
/**
* Builds a SCRIPT[type="javascript"] tag
*
* <code>
* echo Phalcon\Tag::javascriptInclude("http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js", false);
* echo Phalcon\Tag::javascriptInclude("javascript/jquery.js");
* </code>
*
* Volt syntax:
* <code>
* {{ javascript_include("http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js", false) }}
* {{ javascript_include("javascript/jquery.js") }}
* </code>
*
* @param array $parameters
* @param boolean $local
* @return string
*/
PHP_METHOD(Phalcon_Tag, javascriptInclude){
zval *parameters = NULL, *local = NULL, *params = NULL, *first_param;
zval *url, *params_src, *src, *code, *value = NULL, *key = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zz", ¶meters, &local) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!parameters) {
PHALCON_INIT_NVAR(parameters);
}
if (!local) {
PHALCON_INIT_NVAR(local);
ZVAL_BOOL(local, 1);
} else {
PHALCON_SEPARATE_PARAM(local);
}
if (Z_TYPE_P(parameters) != IS_ARRAY) {
PHALCON_INIT_VAR(params);
array_init(params);
phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(¶ms, local, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_CPY_WRT(params, parameters);
}
eval_int = phalcon_array_isset_string(params, SS("src"));
if (!eval_int) {
eval_int = phalcon_array_isset_long(params, 0);
if (eval_int) {
PHALCON_INIT_VAR(first_param);
phalcon_array_fetch_long(&first_param, params, 0, PH_NOISY_CC);
phalcon_array_update_string(¶ms, SL("src"), &first_param, PH_COPY | PH_SEPARATE TSRMLS_CC);
} else {
phalcon_array_update_string_string(¶ms, SL("src"), SL(""), PH_SEPARATE TSRMLS_CC);
}
}
PHALCON_INIT_NVAR(local);
ZVAL_STRING(local, "", 1);
eval_int = phalcon_array_isset_long(params, 1);
if (eval_int) {
PHALCON_INIT_NVAR(local);
phalcon_array_fetch_long(&local, params, 1, PH_NOISY_CC);
} else {
eval_int = phalcon_array_isset_string(params, SS("local"));
if (eval_int) {
PHALCON_INIT_NVAR(local);
phalcon_array_fetch_string(&local, params, SL("local"), PH_NOISY_CC);
PHALCON_SEPARATE(params);
phalcon_array_unset_string(params, SS("local"));
}
}
eval_int = phalcon_array_isset_string(params, SS("type"));
if (!eval_int) {
phalcon_array_update_string_string(¶ms, SL("type"), SL("text/javascript"), PH_SEPARATE TSRMLS_CC);
}
if (zend_is_true(local)) {
PHALCON_INIT_VAR(url);
PHALCON_CALL_SELF(url, this_ptr, "geturlservice");
PHALCON_INIT_VAR(params_src);
phalcon_array_fetch_string(¶ms_src, params, SL("src"), PH_NOISY_CC);
PHALCON_INIT_VAR(src);
PHALCON_CALL_METHOD_PARAMS_1(src, url, "get", params_src, PH_NO_CHECK);
phalcon_array_update_string(¶ms, SL("src"), &src, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(code);
ZVAL_STRING(code, "<script", 1);
if (!phalcon_valid_foreach(params TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(params);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
ph_cycle_start_0:
if (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS) {
goto ph_cycle_end_0;
}
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(value);
if (Z_TYPE_P(key) != IS_LONG) {
PHALCON_SCONCAT_SVSVS(code, " ", key, "=\"", value, "\"");
}
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
phalcon_concat_self_str(code, SL("></script>") TSRMLS_CC);
RETURN_CTOR(code);
}
/**
* Builds a HTML A tag using framework conventions
*
*<code>
* echo Phalcon\Tag::linkTo('signup/register', 'Register Here!');
*</code>
*
* @param array $parameters
* @return string
*/
PHP_METHOD(Phalcon_Tag, linkTo){
zval *parameters, *text = NULL, *params = NULL, *action = NULL, *url, *internal_url;
zval *code, *value = NULL, *key = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", ¶meters, &text) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!text) {
PHALCON_INIT_NVAR(text);
} else {
PHALCON_SEPARATE_PARAM(text);
}
if (Z_TYPE_P(parameters) != IS_ARRAY) {
PHALCON_INIT_VAR(params);
array_init(params);
phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(¶ms, text, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_CPY_WRT(params, parameters);
}
PHALCON_INIT_VAR(action);
ZVAL_STRING(action, "", 1);
eval_int = phalcon_array_isset_long(params, 0);
if (eval_int) {
PHALCON_INIT_NVAR(action);
phalcon_array_fetch_long(&action, params, 0, PH_NOISY_CC);
} else {
eval_int = phalcon_array_isset_string(params, SS("action"));
if (eval_int) {
PHALCON_INIT_NVAR(action);
phalcon_array_fetch_string(&action, params, SL("action"), PH_NOISY_CC);
PHALCON_SEPARATE(params);
phalcon_array_unset_string(params, SS("action"));
}
}
PHALCON_INIT_NVAR(text);
ZVAL_STRING(text, "", 1);
eval_int = phalcon_array_isset_long(params, 1);
if (eval_int) {
PHALCON_INIT_NVAR(text);
phalcon_array_fetch_long(&text, params, 1, PH_NOISY_CC);
} else {
eval_int = phalcon_array_isset_string(params, SS("text"));
if (eval_int) {
PHALCON_INIT_NVAR(text);
phalcon_array_fetch_string(&text, params, SL("text"), PH_NOISY_CC);
PHALCON_SEPARATE(params);
phalcon_array_unset_string(params, SS("text"));
}
}
PHALCON_INIT_VAR(url);
PHALCON_CALL_SELF(url, this_ptr, "geturlservice");
PHALCON_INIT_VAR(internal_url);
PHALCON_CALL_METHOD_PARAMS_1(internal_url, url, "get", action, PH_NO_CHECK);
PHALCON_INIT_VAR(code);
PHALCON_CONCAT_SVS(code, "<a href=\"", internal_url, "\"");
if (!phalcon_valid_foreach(params TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(params);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
ph_cycle_start_0:
if (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS) {
goto ph_cycle_end_0;
}
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(value);
if (Z_TYPE_P(key) != IS_LONG) {
PHALCON_SCONCAT_SVSVS(code, " ", key, "=\"", value, "\"");
}
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
PHALCON_SCONCAT_SVS(code, ">", text, "</a>");
RETURN_CTOR(code);
}
/**
* Returns a slice of the resultset to show in the pagination
*
* @return stdClass
*/
PHP_METHOD(Phalcon_Paginator_Adapter_Model, getPaginate){
zval *v0 = NULL, *v1 = NULL, *v2 = NULL, *v3 = NULL, *v4 = NULL, *v5 = NULL, *v6 = NULL;
zval *v7 = NULL, *v8 = NULL, *v9 = NULL, *v10 = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL, *t6 = NULL;
zval *t7 = NULL, *t8 = NULL, *t9 = NULL, *t10 = NULL, *t11 = NULL, *t12 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL, *r13 = NULL;
zval *r14 = NULL, *r15 = NULL, *r16 = NULL, *r17 = NULL, *r18 = NULL, *r19 = NULL, *r20 = NULL;
zval *r21 = NULL, *r22 = NULL, *r23 = NULL, *r24 = NULL, *r25 = NULL, *r26 = NULL, *r27 = NULL;
zval *r28 = NULL;
zval *i0 = NULL, *i1 = NULL, *i2 = NULL;
zval *a0 = NULL;
zval *p2[] = { NULL }, *p3[] = { NULL }, *p4[] = { NULL }, *p5[] = { NULL };
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_limitRows", sizeof("_limitRows")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
PHALCON_CPY_WRT(v0, t0);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_config", sizeof("_config")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch_string(&r0, t1, "data", strlen("data"), PHALCON_NOISY_FETCH TSRMLS_CC);
PHALCON_CPY_WRT(v1, r0);
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, "_page", sizeof("_page")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
PHALCON_CPY_WRT(v2, t2);
if (Z_TYPE_P(v2) == IS_NULL) {
PHALCON_INIT_VAR(v2);
ZVAL_LONG(v2, 1);
}
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_FUNC_PARAMS_1(r1, "count", v1, 0x008);
PHALCON_CPY_WRT(v3, r1);
PHALCON_ALLOC_ZVAL_MM(i0);
object_init(i0);
PHALCON_CPY_WRT(v4, i0);
PHALCON_INIT_VAR(t3);
ZVAL_LONG(t3, 1);
PHALCON_ALLOC_ZVAL_MM(r2);
sub_function(r2, v2, t3 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r3);
mul_function(r3, v0, r2 TSRMLS_CC);
PHALCON_CPY_WRT(v5, r3);
PHALCON_ALLOC_ZVAL_MM(r4);
PHALCON_INIT_VAR(t4);
ZVAL_LONG(t4, 1);
PHALCON_ALLOC_ZVAL_MM(r5);
sub_function(r5, v3, t4 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r6);
div_function(r6, r5, v0 TSRMLS_CC);
Z_ADDREF_P(r6);
PHALCON_CALL_FUNC_PARAMS_1(r4, "ceil", r6, 0x00D);
Z_DELREF_P(r6);
PHALCON_CPY_WRT(v6, r4);
if (Z_TYPE_P(v1) != IS_OBJECT) {
PHALCON_ALLOC_ZVAL_MM(i1);
object_init_ex(i1, phalcon_paginator_exception_class_entry);
PHALCON_INIT_VAR(p2[0]);
ZVAL_STRING(p2[0], "Invalid data for paginator", 1);
PHALCON_CALL_METHOD_PARAMS_NORETURN(i1, "__construct", 1, p2, PHALCON_CALL_CHECK);
zend_throw_exception_object(i1 TSRMLS_CC);
Z_ADDREF_P(i1);
PHALCON_MM_RESTORE();
return;
}
if (Z_TYPE_P(v2) == IS_NULL) {
PHALCON_INIT_VAR(v2);
ZVAL_LONG(v2, 0);
}
PHALCON_INIT_VAR(t5);
ZVAL_LONG(t5, 0);
PHALCON_INIT_VAR(r7);
is_smaller_function(r7, v5, t5 TSRMLS_CC);
if (zend_is_true(r7)) {
PHALCON_ALLOC_ZVAL_MM(i2);
object_init_ex(i2, phalcon_paginator_exception_class_entry);
PHALCON_INIT_VAR(p3[0]);
ZVAL_STRING(p3[0], "The start page number is zero or less", 1);
PHALCON_CALL_METHOD_PARAMS_NORETURN(i2, "__construct", 1, p3, PHALCON_CALL_CHECK);
zend_throw_exception_object(i2 TSRMLS_CC);
Z_ADDREF_P(i2);
PHALCON_MM_RESTORE();
return;
}
PHALCON_INIT_VAR(a0);
array_init(a0);
phalcon_update_property_zval(v4, "items", strlen("items"), a0 TSRMLS_CC);
PHALCON_INIT_VAR(t6);
ZVAL_LONG(t6, 0);
PHALCON_INIT_VAR(r8);
is_smaller_function(r8, t6, v3 TSRMLS_CC);
if (zend_is_true(r8)) {
PHALCON_INIT_VAR(r9);
is_smaller_or_equal_function(r9, v5, v3 TSRMLS_CC);
if (zend_is_true(r9)) {
Z_ADDREF_P(v5);
p4[0] = v5;
PHALCON_CALL_METHOD_PARAMS_NORETURN(v1, "seek", 1, p4, PHALCON_CALL_DEFAULT);
Z_DELREF_P(p4[0]);
} else {
PHALCON_INIT_VAR(p5[0]);
ZVAL_LONG(p5[0], 1);
PHALCON_CALL_METHOD_PARAMS_NORETURN(v1, "seek", 1, p5, PHALCON_CALL_DEFAULT);
PHALCON_INIT_VAR(v2);
ZVAL_LONG(v2, 1);
}
PHALCON_INIT_VAR(v7);
ZVAL_LONG(v7, 1);
ws_e435_0:
PHALCON_INIT_VAR(r10);
PHALCON_CALL_METHOD(r10, v1, "valid", PHALCON_CALL_DEFAULT);
if (!zend_is_true(r10)) {
goto we_e435_0;
}
PHALCON_INIT_VAR(r11);
PHALCON_CALL_METHOD(r11, v1, "current", PHALCON_CALL_DEFAULT);
PHALCON_INIT_VAR(t7);
phalcon_read_property(&t7, v4, "items", sizeof("items")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
Z_ADDREF_P(r11);
phalcon_array_append(t7, r11 TSRMLS_CC);
phalcon_update_property_zval(v4, "items", strlen("items"), t7 TSRMLS_CC);
PHALCON_INIT_VAR(r12);
is_smaller_or_equal_function(r12, v0, v7 TSRMLS_CC);
if (zend_is_true(r12)) {
goto we_e435_0;
}
PHALCON_SEPARATE(v7);
increment_function(v7);
goto ws_e435_0;
we_e435_0:
if(0) { };
}
phalcon_update_property_long(v4, "first", strlen("first"), 1 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r13);
phalcon_add_function(r13, v5, v0 TSRMLS_CC);
PHALCON_INIT_VAR(r14);
is_smaller_function(r14, r13, v3 TSRMLS_CC);
if (zend_is_true(r14)) {
PHALCON_INIT_VAR(t8);
ZVAL_LONG(t8, 1);
PHALCON_ALLOC_ZVAL_MM(r15);
phalcon_add_function(r15, v2, t8 TSRMLS_CC);
PHALCON_CPY_WRT(v8, r15);
} else {
PHALCON_ALLOC_ZVAL_MM(r16);
phalcon_add_function(r16, v5, v0 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r17);
is_equal_function(r17, r16, v3 TSRMLS_CC);
if (zend_is_true(r17)) {
PHALCON_CPY_WRT(v8, v3);
} else {
PHALCON_ALLOC_ZVAL_MM(r18);
PHALCON_ALLOC_ZVAL_MM(r19);
div_function(r19, v3, v0 TSRMLS_CC);
PHALCON_CALL_FUNC_PARAMS_1(r18, "intval", r19, 0x00E);
PHALCON_INIT_VAR(t9);
ZVAL_LONG(t9, 1);
PHALCON_ALLOC_ZVAL_MM(r20);
phalcon_add_function(r20, r18, t9 TSRMLS_CC);
PHALCON_CPY_WRT(v8, r20);
}
}
PHALCON_INIT_VAR(r21);
is_smaller_function(r21, v6, v8 TSRMLS_CC);
if (zend_is_true(r21)) {
PHALCON_CPY_WRT(v8, v6);
}
phalcon_update_property_zval(v4, "next", strlen("next"), v8 TSRMLS_CC);
PHALCON_INIT_VAR(t10);
ZVAL_LONG(t10, 1);
PHALCON_INIT_VAR(r22);
is_smaller_function(r22, t10, v2 TSRMLS_CC);
if (zend_is_true(r22)) {
PHALCON_INIT_VAR(t11);
ZVAL_LONG(t11, 1);
PHALCON_ALLOC_ZVAL_MM(r23);
sub_function(r23, v2, t11 TSRMLS_CC);
PHALCON_CPY_WRT(v9, r23);
} else {
PHALCON_INIT_VAR(v9);
ZVAL_LONG(v9, 1);
}
phalcon_update_property_zval(v4, "before", strlen("before"), v9 TSRMLS_CC);
phalcon_update_property_zval(v4, "current", strlen("current"), v2 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r24);
mod_function(r24, v3, v0 TSRMLS_CC);
if (zend_is_true(r24)) {
PHALCON_ALLOC_ZVAL_MM(r25);
PHALCON_ALLOC_ZVAL_MM(r26);
div_function(r26, v3, v0 TSRMLS_CC);
PHALCON_CALL_FUNC_PARAMS_1(r25, "intval", r26, 0x00E);
PHALCON_INIT_VAR(t12);
ZVAL_LONG(t12, 1);
PHALCON_ALLOC_ZVAL_MM(r27);
phalcon_add_function(r27, r25, t12 TSRMLS_CC);
PHALCON_CPY_WRT(v10, r27);
} else {
PHALCON_ALLOC_ZVAL_MM(r28);
div_function(r28, v3, v0 TSRMLS_CC);
PHALCON_CPY_WRT(v10, r28);
}
phalcon_update_property_zval(v4, "last", strlen("last"), v10 TSRMLS_CC);
phalcon_update_property_zval(v4, "total_pages", strlen("total_pages"), v10 TSRMLS_CC);
PHALCON_RETURN_CTOR(v4);
}
/**
* Shows a backtrace item
*
* @param int $n
* @param array $trace
*/
PHP_METHOD(Phalcon_Debug, showTraceItem){
zval *n, *trace, *space, *two_spaces, *underscore;
zval *minus, *html, *class_name, *pattern, *is_phalcon_class;
zval *namespace_separator, *prepare_uri_class;
zval *class_reflection, *is_internal = NULL, *lower_class_name;
zval *prepare_internal_class, *type, *function_name = NULL;
zval *function_reflection, *prepared_function_name;
zval *trace_args, *arguments, *argument = NULL, *dumped_argument = NULL;
zval *span_argument = NULL, *joined_arguments, *one;
zval *file, *line, *show_files, *lines, *number_lines;
zval *show_file_fragment, *seven, *before_line;
zval *first_line = NULL, *five, *after_line, *last_line = NULL;
zval *comment_pattern, *utf8, *ent_compat, *tab;
zval *comment, *i = NULL, *line_position = NULL, *current_line = NULL;
zval *trimmed = NULL, *is_comment = NULL, *spaced_current_line = NULL;
zval *escaped_line = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
zend_class_entry *ce0, *ce1;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &n, &trace);
PHALCON_INIT_VAR(space);
ZVAL_STRING(space, " ", 1);
PHALCON_INIT_VAR(two_spaces);
ZVAL_STRING(two_spaces, " ", 1);
PHALCON_INIT_VAR(underscore);
ZVAL_STRING(underscore, "_", 1);
PHALCON_INIT_VAR(minus);
ZVAL_STRING(minus, "-", 1);
/**
* Every trace in the backtrace have a unique number
*/
PHALCON_INIT_VAR(html);
PHALCON_CONCAT_SVS(html, "<tr><td align=\"right\" valign=\"top\" class=\"error-number\">#", n, "</td><td>");
if (phalcon_array_isset_string(trace, SS("class"))) {
PHALCON_OBS_VAR(class_name);
phalcon_array_fetch_string(&class_name, trace, SL("class"), PH_NOISY);
PHALCON_INIT_VAR(pattern);
ZVAL_STRING(pattern, "/^Phalcon/", 1);
PHALCON_INIT_VAR(is_phalcon_class);
phalcon_preg_match(is_phalcon_class, pattern, class_name, NULL TSRMLS_CC);
/**
* We assume that classes starting by Phalcon are framework's classes
*/
if (zend_is_true(is_phalcon_class)) {
PHALCON_INIT_VAR(namespace_separator);
ZVAL_STRING(namespace_separator, "\\", 1);
/**
* Prepare the class name according to the Phalcon's conventions
*/
PHALCON_INIT_VAR(prepare_uri_class);
phalcon_fast_str_replace(prepare_uri_class, namespace_separator, underscore, class_name);
/**
* Generate a link to the official docs
*/
PHALCON_SCONCAT_SVSVS(html, "<span class=\"error-class\"><a target=\"_new\" href=\"http://docs.phalconphp.com/en/latest/api/", prepare_uri_class, ".html\">", class_name, "</a></span>");
} else {
ce0 = zend_fetch_class(SL("ReflectionClass"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
PHALCON_INIT_VAR(class_reflection);
object_init_ex(class_reflection, ce0);
if (phalcon_has_constructor(class_reflection TSRMLS_CC)) {
phalcon_call_method_p1_noret(class_reflection, "__construct", class_name);
}
/**
* Check if classes are PHP's classes
*/
PHALCON_INIT_VAR(is_internal);
phalcon_call_method(is_internal, class_reflection, "isinternal");
if (zend_is_true(is_internal)) {
PHALCON_INIT_VAR(lower_class_name);
phalcon_fast_strtolower(lower_class_name, class_name);
PHALCON_INIT_VAR(prepare_internal_class);
phalcon_fast_str_replace(prepare_internal_class, underscore, minus, lower_class_name);
/**
* Generate a link to the official docs
*/
PHALCON_SCONCAT_SVSVS(html, "<span class=\"error-class\"><a target=\"_new\" href=\"http://php.net/manual/en/class.", prepare_internal_class, ".php\">", class_name, "</a></span>");
} else {
PHALCON_SCONCAT_SVS(html, "<span class=\"error-class\">", class_name, "</span>");
}
}
/**
* Object access operator: static/instance
*/
PHALCON_OBS_VAR(type);
phalcon_array_fetch_string(&type, trace, SL("type"), PH_NOISY);
phalcon_concat_self(&html, type TSRMLS_CC);
}
/**
* Normally the backtrace contains only classes
*/
if (phalcon_array_isset_string(trace, SS("class"))) {
PHALCON_OBS_VAR(function_name);
phalcon_array_fetch_string(&function_name, trace, SL("function"), PH_NOISY);
PHALCON_SCONCAT_SVS(html, "<span class=\"error-function\">", function_name, "</span>");
} else {
PHALCON_OBS_NVAR(function_name);
phalcon_array_fetch_string(&function_name, trace, SL("function"), PH_NOISY);
/**
* Check if the function exists
*/
if (phalcon_function_exists(function_name TSRMLS_CC) == SUCCESS) {
ce1 = zend_fetch_class(SL("ReflectionFunction"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
PHALCON_INIT_VAR(function_reflection);
object_init_ex(function_reflection, ce1);
if (phalcon_has_constructor(function_reflection TSRMLS_CC)) {
phalcon_call_method_p1_noret(function_reflection, "__construct", function_name);
}
PHALCON_INIT_NVAR(is_internal);
phalcon_call_method(is_internal, function_reflection, "isinternal");
/**
* Internal functions links to the PHP documentation
*/
if (zend_is_true(is_internal)) {
/**
* Prepare function's name according to the conventions in the docs
*/
PHALCON_INIT_VAR(prepared_function_name);
phalcon_fast_str_replace(prepared_function_name, underscore, minus, function_name);
PHALCON_SCONCAT_SVSVS(html, "<span class=\"error-function\"><a target=\"_new\" href=\"http://php.net/manual/en/function.", prepared_function_name, ".php\">", function_name, "</a></span>");
} else {
PHALCON_SCONCAT_SVS(html, "<span class=\"error-function\">", function_name, "</span>");
}
} else {
PHALCON_SCONCAT_SVS(html, "<span class=\"error-function\">", function_name, "</span>");
}
}
/**
* Check for arguments in the function
*/
if (phalcon_array_isset_string(trace, SS("args"))) {
PHALCON_OBS_VAR(trace_args);
phalcon_array_fetch_string(&trace_args, trace, SL("args"), PH_NOISY);
if (phalcon_fast_count_ev(trace_args TSRMLS_CC)) {
PHALCON_INIT_VAR(arguments);
array_init(arguments);
phalcon_is_iterable(trace_args, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(argument);
/**
* Every argument is generated using _getVarDump
*/
PHALCON_INIT_NVAR(dumped_argument);
phalcon_call_method_p1(dumped_argument, this_ptr, "_getvardump", argument);
PHALCON_INIT_NVAR(span_argument);
PHALCON_CONCAT_SVS(span_argument, "<span class=\"error-parameter\">", dumped_argument, "</span>");
/**
* Append the HTML generated to the argument's list
*/
phalcon_array_append(&arguments, span_argument, PH_SEPARATE);
zend_hash_move_forward_ex(ah0, &hp0);
}
/**
* Join all the arguments
*/
PHALCON_INIT_VAR(joined_arguments);
phalcon_fast_join_str(joined_arguments, SL(", "), arguments TSRMLS_CC);
PHALCON_SCONCAT_SVS(html, "(", joined_arguments, ")");
} else {
phalcon_concat_self_str(&html, SL("()") TSRMLS_CC);
}
}
/**
* When 'file' is present, it usually means the function is provided by the user
*/
if (phalcon_array_isset_string(trace, SS("file"))) {
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
PHALCON_OBS_VAR(file);
phalcon_array_fetch_string(&file, trace, SL("file"), PH_NOISY);
PHALCON_OBS_VAR(line);
phalcon_array_fetch_string(&line, trace, SL("line"), PH_NOISY);
/**
* Realpath to the file and its line using a special header
*/
PHALCON_SCONCAT_SVSVS(html, "<br/><div class=\"error-file\">", file, " (", line, ")</div>");
PHALCON_OBS_VAR(show_files);
phalcon_read_property_this(&show_files, this_ptr, SL("_showFiles"), PH_NOISY_CC);
/**
* The developer can change if the files must be opened or not
*/
if (zend_is_true(show_files)) {
/**
* Open the file to an array using 'file', this respects the openbase-dir directive
*/
PHALCON_INIT_VAR(lines);
phalcon_call_func_p1(lines, "file", file);
PHALCON_INIT_VAR(number_lines);
phalcon_fast_count(number_lines, lines TSRMLS_CC);
PHALCON_OBS_VAR(show_file_fragment);
phalcon_read_property_this(&show_file_fragment, this_ptr, SL("_showFileFragment"), PH_NOISY_CC);
/**
* File fragments just show a piece of the file where the exception is located
*/
if (zend_is_true(show_file_fragment)) {
/**
* Take seven lines back to the current exception's line, @TODO add an option for
* this
*/
PHALCON_INIT_VAR(seven);
ZVAL_LONG(seven, 7);
PHALCON_INIT_VAR(before_line);
sub_function(before_line, line, seven TSRMLS_CC);
/**
* Check for overflows
*/
if (PHALCON_LT_LONG(before_line, 1)) {
PHALCON_CPY_WRT(first_line, one);
} else {
PHALCON_CPY_WRT(first_line, before_line);
}
/**
* Take five lines after the current exception's line, @TODO add an option for this
*/
PHALCON_INIT_VAR(five);
ZVAL_LONG(five, 5);
PHALCON_INIT_VAR(after_line);
phalcon_add_function(after_line, line, five TSRMLS_CC);
/**
* Check for overflows
*/
if (PHALCON_GT(after_line, number_lines)) {
PHALCON_CPY_WRT(last_line, number_lines);
} else {
PHALCON_CPY_WRT(last_line, after_line);
}
PHALCON_SCONCAT_SVSVSVS(html, "<pre class='prettyprint highlight:", first_line, ":", line, " linenums:", first_line, "'>");
} else {
PHALCON_CPY_WRT(first_line, one);
PHALCON_CPY_WRT(last_line, number_lines);
PHALCON_SCONCAT_SVSVS(html, "<pre class='prettyprint highlight:", first_line, ":", line, " linenums error-scroll'>");
}
PHALCON_INIT_VAR(comment_pattern);
ZVAL_STRING(comment_pattern, "#\\*\\/$#", 1);
/**
* We assume the file is utf-8 encoded, @TODO add an option for this
*/
PHALCON_INIT_VAR(utf8);
ZVAL_STRING(utf8, "UTF-8", 1);
/**
* Don't escape quotes
*/
PHALCON_INIT_VAR(ent_compat);
ZVAL_LONG(ent_compat, 2);
PHALCON_INIT_VAR(tab);
ZVAL_STRING(tab, "\t", 1);
PHALCON_INIT_VAR(comment);
ZVAL_STRING(comment, "* /", 1);
PHALCON_CPY_WRT(i, first_line);
while (1) {
if (PHALCON_LE(i, last_line)) {
} else {
break;
}
/**
* Current line in the file
*/
PHALCON_INIT_NVAR(line_position);
sub_function(line_position, i, one TSRMLS_CC);
/**
* Current line content in the piece of file
*/
PHALCON_OBS_NVAR(current_line);
phalcon_array_fetch(¤t_line, lines, line_position, PH_NOISY);
/**
* File fragments are cleaned, removing tabs and comments
*/
if (zend_is_true(show_file_fragment)) {
if (PHALCON_IS_EQUAL(i, first_line)) {
PHALCON_INIT_NVAR(trimmed);
phalcon_fast_trim(trimmed, current_line, PHALCON_TRIM_RIGHT TSRMLS_CC);
PHALCON_INIT_NVAR(is_comment);
phalcon_preg_match(is_comment, comment_pattern, current_line, NULL TSRMLS_CC);
if (zend_is_true(is_comment)) {
PHALCON_INIT_NVAR(spaced_current_line);
phalcon_fast_str_replace(spaced_current_line, comment, space, current_line);
PHALCON_CPY_WRT(current_line, spaced_current_line);
}
}
}
/**
* Print a non break space if the current line is a line break, this allows to show
* the html zebra properly
*/
if (PHALCON_IS_STRING(current_line, "\n")) {
phalcon_concat_self_str(&html, SL(" \n") TSRMLS_CC);
} else {
if (PHALCON_IS_STRING(current_line, "\r\n")) {
phalcon_concat_self_str(&html, SL(" \n") TSRMLS_CC);
} else {
PHALCON_INIT_NVAR(spaced_current_line);
phalcon_fast_str_replace(spaced_current_line, tab, two_spaces, current_line);
PHALCON_INIT_NVAR(escaped_line);
phalcon_call_func_p3(escaped_line, "htmlentities", spaced_current_line, ent_compat, utf8);
phalcon_concat_self(&html, escaped_line TSRMLS_CC);
}
}
PHALCON_SEPARATE(i);
phalcon_increment(i);
}
phalcon_concat_self_str(&html, SL("</pre>") TSRMLS_CC);
}
}
phalcon_concat_self_str(&html, SL("</td></tr>") TSRMLS_CC);
RETURN_CTOR(html);
}
/**
* Routes to a controller/action using a string or array uri
*
* @param string $uri
*/
PHP_METHOD(Phalcon_Dispatcher, forward){
zval *uri = NULL, *parts = NULL, *params = NULL, *value = NULL, *key = NULL;
zval *c0 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL;
zval *a0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &uri) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(uri) == IS_ARRAY) {
PHALCON_CPY_WRT(parts, uri);
} else {
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "/", 1);
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_fast_explode(r0, c0, uri TSRMLS_CC);
PHALCON_CPY_WRT(parts, r0);
}
eval_int = phalcon_array_isset_long(parts, 0);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_array_fetch_long(&r1, parts, 0, PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r2);
phalcon_filter_alphanum(r2, r1);
phalcon_update_property_zval(this_ptr, SL("_controllerName"), r2 TSRMLS_CC);
PHALCON_SEPARATE(parts);
phalcon_array_unset_long(parts, 0);
} else {
eval_int = phalcon_array_isset_string(parts, SL("controller")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r3);
phalcon_array_fetch_string(&r3, parts, SL("controller"), PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r4);
phalcon_filter_alphanum(r4, r3);
phalcon_update_property_zval(this_ptr, SL("_controllerName"), r4 TSRMLS_CC);
} else {
PHALCON_ALLOC_ZVAL_MM(r5);
PHALCON_CALL_METHOD(r5, this_ptr, "getcontrollername", PHALCON_NO_CHECK);
phalcon_update_property_zval(this_ptr, SL("_controllerName"), r5 TSRMLS_CC);
}
}
eval_int = phalcon_array_isset_long(parts, 1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r6);
phalcon_array_fetch_long(&r6, parts, 1, PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r7);
phalcon_filter_alphanum(r7, r6);
phalcon_update_property_zval(this_ptr, SL("_actionName"), r7 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r8);
phalcon_array_fetch_long(&r8, parts, 1, PHALCON_NOISY TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_actionName"), r8 TSRMLS_CC);
PHALCON_SEPARATE(parts);
phalcon_array_unset_long(parts, 1);
} else {
eval_int = phalcon_array_isset_string(parts, SL("action")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r9);
phalcon_array_fetch_string(&r9, parts, SL("action"), PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r10);
phalcon_filter_alphanum(r10, r9);
phalcon_update_property_zval(this_ptr, SL("_actionName"), r10 TSRMLS_CC);
} else {
PHALCON_ALLOC_ZVAL_MM(r11);
PHALCON_CALL_METHOD(r11, this_ptr, "getactionname", PHALCON_NO_CHECK);
phalcon_update_property_zval(this_ptr, SL("_actionName"), r11 TSRMLS_CC);
}
}
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(params, a0);
if (phalcon_valid_foreach(parts TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(parts);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_e10f_1:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_e10f_1;
} else {
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
}
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
if (Z_TYPE_P(key) == IS_LONG) {
PHALCON_INIT_VAR(r12);
phalcon_array_fetch(&r12, parts, key, PHALCON_NOISY TSRMLS_CC);
phalcon_array_append(¶ms, r12, PHALCON_SEPARATE_PLZ TSRMLS_CC);
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_e10f_1;
fee_e10f_1:
if(0){}
} else {
return;
}
phalcon_update_property_zval(this_ptr, SL("_params"), params TSRMLS_CC);
phalcon_update_property_bool(this_ptr, SL("_finished"), 0 TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Returns a slice of the resultset to show in the pagination
*
* @return stdClass
*/
PHP_METHOD(Phalcon_Paginator_Adapter_Model, getPaginate){
zval *one, *zero, *show, *config, *items, *page_number = NULL;
zval *smaller, *n, *page, *last_show_page, *start;
zval *last_page, *possible_pages = NULL, *total_pages;
zval *compare = NULL, *page_items, *i, *valid = NULL, *current = NULL, *maximum_pages;
zval *next = NULL, *additional_page, *before = NULL, *remainder;
zval *pages_total = NULL;
zval *r0 = NULL;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
PHALCON_INIT_VAR(zero);
ZVAL_LONG(zero, 0);
PHALCON_OBS_VAR(show);
phalcon_read_property(&show, this_ptr, SL("_limitRows"), PH_NOISY_CC);
PHALCON_OBS_VAR(config);
phalcon_read_property(&config, this_ptr, SL("_config"), PH_NOISY_CC);
PHALCON_OBS_VAR(items);
phalcon_array_fetch_string(&items, config, SL("data"), PH_NOISY_CC);
PHALCON_OBS_VAR(page_number);
phalcon_read_property(&page_number, this_ptr, SL("_page"), PH_NOISY_CC);
if (Z_TYPE_P(page_number) == IS_NULL) {
PHALCON_CPY_WRT(page_number, one);
}
PHALCON_INIT_VAR(smaller);
is_smaller_function(smaller, show, zero TSRMLS_CC);
if (PHALCON_IS_TRUE(smaller)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_paginator_exception_ce, "The start page number is zero or less");
return;
}
PHALCON_INIT_VAR(n);
phalcon_fast_count(n, items TSRMLS_CC);
PHALCON_INIT_VAR(page);
object_init(page);
PHALCON_INIT_VAR(last_show_page);
sub_function(last_show_page, page_number, one TSRMLS_CC);
PHALCON_INIT_VAR(start);
mul_function(start, show, last_show_page TSRMLS_CC);
PHALCON_INIT_VAR(last_page);
sub_function(last_page, n, one TSRMLS_CC);
PHALCON_INIT_VAR(possible_pages);
div_function(possible_pages, last_page, show TSRMLS_CC);
PHALCON_INIT_VAR(total_pages);
PHALCON_CALL_FUNC_PARAMS_1(total_pages, "ceil", possible_pages);
if (Z_TYPE_P(items) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_paginator_exception_ce, "Invalid data for paginator");
return;
}
if (Z_TYPE_P(page_number) == IS_NULL) {
PHALCON_CPY_WRT(page_number, zero);
}
PHALCON_INIT_VAR(compare);
is_smaller_function(compare, start, zero TSRMLS_CC);
if (PHALCON_IS_TRUE(compare)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_paginator_exception_ce, "The start page number is zero or less");
return;
}
PHALCON_INIT_VAR(page_items);
array_init(page_items);
is_smaller_function(compare, zero, n TSRMLS_CC);
if (PHALCON_IS_TRUE(compare)) {
/**
* Seek to the desired position
*/
is_smaller_or_equal_function(compare, start, n TSRMLS_CC);
if (PHALCON_IS_TRUE(compare)) {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(items, "seek", start);
} else {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(items, "seek", one);
PHALCON_CPY_WRT(page_number, one);
}
/**
* The record must be iterable
*/
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 1);
while (1) {
PHALCON_INIT_NVAR(r0);
PHALCON_CALL_METHOD(r0, items, "valid");
PHALCON_CPY_WRT(valid, r0);
if (PHALCON_IS_NOT_FALSE(valid)) {
} else {
break;
}
PHALCON_INIT_NVAR(current);
PHALCON_CALL_METHOD(current, items, "current");
phalcon_array_append(&page_items, current, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_NVAR(compare);
is_smaller_or_equal_function(compare, show, i TSRMLS_CC);
if (PHALCON_IS_TRUE(compare)) {
break;
}
PHALCON_SEPARATE(i);
increment_function(i);
}
}
phalcon_update_property_zval(page, SL("items"), page_items TSRMLS_CC);
phalcon_update_property_zval(page, SL("first"), one TSRMLS_CC);
PHALCON_INIT_VAR(maximum_pages);
phalcon_add_function(maximum_pages, start, show TSRMLS_CC);
is_smaller_function(compare, maximum_pages, n TSRMLS_CC);
if (PHALCON_IS_TRUE(compare)) {
PHALCON_INIT_VAR(next);
phalcon_add_function(next, page_number, one TSRMLS_CC);
} else {
is_equal_function(compare, maximum_pages, n TSRMLS_CC);
if (PHALCON_IS_TRUE(compare)) {
PHALCON_CPY_WRT(next, n);
} else {
div_function(possible_pages, n, show TSRMLS_CC);
PHALCON_INIT_VAR(additional_page);
phalcon_add_function(additional_page, possible_pages, one TSRMLS_CC);
PHALCON_INIT_NVAR(next);
PHALCON_CALL_FUNC_PARAMS_1(next, "intval", additional_page);
}
}
is_smaller_function(compare, total_pages, next TSRMLS_CC);
if (PHALCON_IS_TRUE(compare)) {
PHALCON_CPY_WRT(next, total_pages);
}
phalcon_update_property_zval(page, SL("next"), next TSRMLS_CC);
is_smaller_function(compare, one, page_number TSRMLS_CC);
if (PHALCON_IS_TRUE(compare)) {
PHALCON_INIT_VAR(before);
sub_function(before, page_number, one TSRMLS_CC);
} else {
PHALCON_CPY_WRT(before, one);
}
phalcon_update_property_zval(page, SL("before"), before TSRMLS_CC);
phalcon_update_property_zval(page, SL("current"), page_number TSRMLS_CC);
PHALCON_INIT_VAR(remainder);
mod_function(remainder, n, show TSRMLS_CC);
div_function(possible_pages, n, show TSRMLS_CC);
if (!PHALCON_IS_LONG(remainder, 0)) {
PHALCON_INIT_NVAR(next);
phalcon_add_function(next, possible_pages, one TSRMLS_CC);
PHALCON_INIT_VAR(pages_total);
PHALCON_CALL_FUNC_PARAMS_1(pages_total, "intval", next);
} else {
PHALCON_CPY_WRT(pages_total, possible_pages);
}
phalcon_update_property_zval(page, SL("last"), pages_total TSRMLS_CC);
phalcon_update_property_zval(page, SL("total_pages"), pages_total TSRMLS_CC);
RETURN_CTOR(page);
}
/**
* Builds a HTML TEXTAREA tag
*
*<code>
* echo Phalcon\Tag::textArea(array("comments", "cols" => 10, "rows" => 4))
*</code>
*
* @param array $parameters
* @return string
*/
PHP_METHOD(Phalcon_Tag, textArea){
zval *parameters, *params = NULL, *id = NULL, *name, *content = NULL, *code;
zval *avalue = NULL, *key = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", ¶meters) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(parameters) != IS_ARRAY) {
PHALCON_INIT_VAR(params);
array_init(params);
phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_CPY_WRT(params, parameters);
}
eval_int = phalcon_array_isset_long(params, 0);
if (!eval_int) {
eval_int = phalcon_array_isset_string(params, SS("id"));
if (eval_int) {
PHALCON_INIT_VAR(id);
phalcon_array_fetch_string(&id, params, SL("id"), PH_NOISY_CC);
phalcon_array_update_long(¶ms, 0, &id, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
}
PHALCON_INIT_NVAR(id);
phalcon_array_fetch_long(&id, params, 0, PH_NOISY_CC);
eval_int = phalcon_array_isset_string(params, SS("name"));
if (!eval_int) {
phalcon_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(name);
phalcon_array_fetch_string(&name, params, SL("name"), PH_NOISY_CC);
if (!zend_is_true(name)) {
phalcon_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
}
eval_int = phalcon_array_isset_string(params, SS("id"));
if (!eval_int) {
phalcon_array_update_string(¶ms, SL("id"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(params, SS("value"));
if (eval_int) {
PHALCON_INIT_VAR(content);
phalcon_array_fetch_string(&content, params, SL("value"), PH_NOISY_CC);
PHALCON_SEPARATE(params);
phalcon_array_unset_string(params, SS("value"));
} else {
PHALCON_INIT_NVAR(content);
PHALCON_CALL_SELF_PARAMS_1(content, this_ptr, "getvalue", id);
}
PHALCON_INIT_VAR(code);
ZVAL_STRING(code, "<textarea", 1);
if (!phalcon_valid_foreach(params TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(params);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
ph_cycle_start_0:
if (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS) {
goto ph_cycle_end_0;
}
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(avalue);
if (Z_TYPE_P(key) != IS_LONG) {
PHALCON_SCONCAT_SVSVS(code, " ", key, "=\"", avalue, "\"");
}
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
PHALCON_SCONCAT_SVS(code, ">", content, "</textarea>");
RETURN_CTOR(code);
}
/**
* Updates data on a table using custom RBDM SQL syntax
*
*
*
* @param string $table
* @param array $fields
* @param array $values
* @param string $whereCondition
* @param boolean $automaticQuotes
* @return boolean
*/
PHP_METHOD(Phalcon_Db, update){
zval *table = NULL, *fields = NULL, *values = NULL, *where_condition = NULL;
zval *automatic_quotes = NULL, *i = NULL, *update_values = NULL, *update_sql = NULL;
zval *field = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL, *r13 = NULL;
zval *r14 = NULL, *r15 = NULL, *r16 = NULL, *r17 = NULL, *r18 = NULL;
zval *a0 = NULL;
zval *c0 = NULL;
zval *t0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz|zz", &table, &fields, &values, &where_condition, &automatic_quotes) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_SEPARATE_PARAM(values);
if (!where_condition) {
PHALCON_INIT_VAR(where_condition);
ZVAL_NULL(where_condition);
}
if (!automatic_quotes) {
PHALCON_INIT_VAR(automatic_quotes);
ZVAL_BOOL(automatic_quotes, 0);
}
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_fast_count(r0, fields TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_fast_count(r1, values TSRMLS_CC);
PHALCON_INIT_VAR(r2);
is_not_equal_function(r2, r0, r1 TSRMLS_CC);
if (zend_is_true(r2)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The number of values to update is not the same as fields");
return;
}
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 0);
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(update_values, a0);
PHALCON_ALLOC_ZVAL_MM(r3);
PHALCON_CONCAT_SVS(r3, "UPDATE ", table, " SET ");
PHALCON_CPY_WRT(update_sql, r3);
if (phalcon_valid_foreach(fields TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(fields);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_e7f0_2:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_e7f0_2;
}
PHALCON_INIT_VAR(field);
ZVAL_ZVAL(field, *hd, 1, 0);
if (zend_is_true(automatic_quotes)) {
PHALCON_INIT_VAR(r4);
phalcon_array_fetch(&r4, values, i, PHALCON_NOISY TSRMLS_CC);
if (Z_TYPE_P(r4) == IS_OBJECT) {
PHALCON_INIT_VAR(r5);
phalcon_array_fetch(&r5, values, i, PHALCON_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(r6);
phalcon_instance_of(r6, r5, phalcon_db_rawvalue_ce TSRMLS_CC);
if (zend_is_true(r6)) {
PHALCON_INIT_VAR(r7);
PHALCON_INIT_VAR(r8);
PHALCON_INIT_VAR(r9);
phalcon_array_fetch(&r9, values, i, PHALCON_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD(r8, r9, "getvalue", PHALCON_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_1(r7, this_ptr, "escapestring", r8, PHALCON_NO_CHECK);
phalcon_array_update(&values, i, &r7, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
goto fes_e7f0_2;
}
}
PHALCON_INIT_VAR(r10);
PHALCON_INIT_VAR(r11);
PHALCON_INIT_VAR(r12);
phalcon_array_fetch(&r12, values, i, PHALCON_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD_PARAMS_1(r11, this_ptr, "escapestring", r12, PHALCON_NO_CHECK);
PHALCON_CONCAT_SVS(r10, "'", r11, "'");
phalcon_array_update(&values, i, &r10, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
}
PHALCON_INIT_VAR(r13);
PHALCON_INIT_VAR(r14);
phalcon_array_fetch(&r14, values, i, PHALCON_NOISY TSRMLS_CC);
PHALCON_CONCAT_VSV(r13, field, " = ", r14);
phalcon_array_append(&update_values, r13, PHALCON_SEPARATE_PLZ TSRMLS_CC);
PHALCON_SEPARATE(i);
increment_function(i);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_e7f0_2;
fee_e7f0_2:
if(0){}
} else {
return;
}
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, ", ", 1);
PHALCON_ALLOC_ZVAL_MM(r15);
phalcon_fast_join(r15, c0, update_values TSRMLS_CC);
phalcon_concat_self(&update_sql, r15 TSRMLS_CC);
PHALCON_INIT_VAR(t0);
ZVAL_NULL(t0);
PHALCON_INIT_VAR(r16);
is_not_equal_function(r16, where_condition, t0 TSRMLS_CC);
if (zend_is_true(r16)) {
PHALCON_ALLOC_ZVAL_MM(r17);
PHALCON_CONCAT_SV(r17, " WHERE ", where_condition);
phalcon_concat_self(&update_sql, r17 TSRMLS_CC);
}
PHALCON_ALLOC_ZVAL_MM(r18);
PHALCON_CALL_METHOD_PARAMS_1(r18, this_ptr, "query", update_sql, PHALCON_NO_CHECK);
PHALCON_RETURN_DZVAL(r18);
}
/**
* Helper method to query records based on a relation definition
*
* @param array $relation
* @param string $method
* @param Phalcon\Mvc\Model $record
* @param array $parameters
* @return Phalcon\Mvc\Model\Resultset\Simple
*/
PHP_METHOD(Phalcon_Mvc_Model_Manager, _getRelationRecords){
zval *relation = NULL, *method = NULL, *record = NULL, *parameters = NULL, *placeholders = NULL;
zval *pre_conditions = NULL, *conditions = NULL, *fields = NULL, *field = NULL;
zval *value = NULL, *referenced_field = NULL, *condition = NULL, *i = NULL;
zval *referenced_fields = NULL, *join_conditions = NULL;
zval *find_params = NULL, *find_arguments = NULL, *arguments = NULL;
zval *reference_table = NULL, *referenced_entity = NULL;
zval *connection_service = NULL, *call_object = NULL, *records = NULL;
zval *c0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
int eval_int;
zend_class_entry *ce0;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz|z", &relation, &method, &record, ¶meters) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!parameters) {
PHALCON_ALLOC_ZVAL_MM(parameters);
ZVAL_NULL(parameters);
} else {
PHALCON_SEPARATE_PARAM(parameters);
}
if (Z_TYPE_P(parameters) == IS_ARRAY) {
eval_int = phalcon_array_isset_string(parameters, SL("bind")+1);
if (eval_int) {
PHALCON_INIT_VAR(placeholders);
phalcon_array_fetch_string(&placeholders, parameters, SL("bind"), PH_NOISY_CC);
PHALCON_SEPARATE_PARAM(parameters);
phalcon_array_unset_string(parameters, SL("bind")+1);
} else {
PHALCON_INIT_VAR(placeholders);
array_init(placeholders);
}
} else {
PHALCON_INIT_VAR(placeholders);
array_init(placeholders);
}
PHALCON_INIT_VAR(pre_conditions);
ZVAL_NULL(pre_conditions);
if (Z_TYPE_P(parameters) == IS_ARRAY) {
eval_int = phalcon_array_isset_long(parameters, 0);
if (eval_int) {
PHALCON_INIT_VAR(pre_conditions);
phalcon_array_fetch_long(&pre_conditions, parameters, 0, PH_NOISY_CC);
PHALCON_SEPARATE_PARAM(parameters);
phalcon_array_unset_long(parameters, 0);
} else {
eval_int = phalcon_array_isset_string(parameters, SL("conditions")+1);
if (eval_int) {
PHALCON_INIT_VAR(pre_conditions);
phalcon_array_fetch_string(&pre_conditions, parameters, SL("conditions"), PH_NOISY_CC);
PHALCON_SEPARATE_PARAM(parameters);
phalcon_array_unset_string(parameters, SL("conditions")+1);
}
}
} else {
if (Z_TYPE_P(parameters) == IS_STRING) {
PHALCON_CPY_WRT(pre_conditions, parameters);
}
}
if (Z_TYPE_P(pre_conditions) != IS_NULL) {
PHALCON_INIT_VAR(conditions);
array_init(conditions);
phalcon_array_append(&conditions, pre_conditions, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(conditions);
array_init(conditions);
}
PHALCON_INIT_VAR(fields);
phalcon_array_fetch_string(&fields, relation, SL("fi"), PH_NOISY_CC);
if (Z_TYPE_P(fields) != IS_ARRAY) {
PHALCON_CPY_WRT(field, fields);
PHALCON_INIT_VAR(value);
PHALCON_CALL_METHOD_PARAMS_1(value, record, "readattribute", field, PH_NO_CHECK);
PHALCON_INIT_VAR(referenced_field);
phalcon_array_fetch_string(&referenced_field, relation, SL("rf"), PH_NOISY_CC);
PHALCON_INIT_VAR(condition);
PHALCON_CONCAT_VS(condition, referenced_field, " = ?0");
phalcon_array_append(&conditions, condition, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&placeholders, value, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 0);
PHALCON_INIT_VAR(referenced_fields);
phalcon_array_fetch_string(&referenced_fields, relation, SL("rf"), PH_NOISY_CC);
if (!phalcon_valid_foreach(fields TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(fields);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_74b5_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_74b5_0;
}
PHALCON_INIT_VAR(field);
ZVAL_ZVAL(field, *hd, 1, 0);
PHALCON_INIT_VAR(value);
PHALCON_CALL_METHOD_PARAMS_1(value, record, "readattribute", field, PH_NO_CHECK);
PHALCON_INIT_VAR(referenced_field);
phalcon_array_fetch(&referenced_field, referenced_fields, i, PH_NOISY_CC);
PHALCON_INIT_VAR(condition);
PHALCON_CONCAT_VSV(condition, referenced_field, " = ?", i);
phalcon_array_append(&conditions, condition, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&placeholders, value, PH_SEPARATE TSRMLS_CC);
PHALCON_SEPARATE(i);
increment_function(i);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_74b5_0;
fee_74b5_0:
if(0){}
}
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, " AND ", 1);
PHALCON_INIT_VAR(join_conditions);
phalcon_fast_join(join_conditions, c0, conditions TSRMLS_CC);
PHALCON_INIT_VAR(find_params);
array_init(find_params);
phalcon_array_append(&find_params, join_conditions, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&find_params, SL("bind"), &placeholders, PH_COPY | PH_SEPARATE TSRMLS_CC);
if (Z_TYPE_P(parameters) == IS_ARRAY) {
PHALCON_INIT_VAR(find_arguments);
PHALCON_CALL_FUNC_PARAMS_2(find_arguments, "array_merge", find_params, parameters);
} else {
PHALCON_CPY_WRT(find_arguments, find_params);
}
PHALCON_INIT_VAR(arguments);
array_init(arguments);
phalcon_array_append(&arguments, find_arguments, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(reference_table);
phalcon_array_fetch_string(&reference_table, relation, SL("rt"), PH_NOISY_CC);
ce0 = phalcon_fetch_class(reference_table TSRMLS_CC);
PHALCON_INIT_VAR(referenced_entity);
object_init_ex(referenced_entity, ce0);
PHALCON_CALL_METHOD_NORETURN(referenced_entity, "__construct", PH_CHECK);
PHALCON_INIT_VAR(connection_service);
PHALCON_CALL_METHOD(connection_service, record, "getconnectionservice", PH_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(referenced_entity, "setconnectionservice", connection_service, PH_NO_CHECK);
PHALCON_INIT_VAR(call_object);
array_init(call_object);
phalcon_array_append(&call_object, referenced_entity, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&call_object, method, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(records);
PHALCON_CALL_FUNC_PARAMS_2(records, "call_user_func_array", call_object, arguments);
RETURN_CCTOR(records);
}
/**
* Helper method to query records based on a relation definition
*
* @param array $relation
* @param string $method
* @param Phalcon\Mvc\Model $record
*/
PHP_METHOD(Phalcon_Mvc_Model_Manager, _getRelationRecords){
zval *relation = NULL, *method = NULL, *record = NULL, *conditions = NULL, *placeholders = NULL;
zval *field = NULL, *value = NULL, *referenced_field = NULL, *condition = NULL;
zval *i = NULL, *fields = NULL, *number_args = NULL, *function_arguments = NULL;
zval *key = NULL, *join_conditions = NULL, *find_params = NULL, *arguments = NULL;
zval *reference_table = NULL, *referenced_entity = NULL;
zval *call_object = NULL, *records = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL;
zval *c0 = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
zend_class_entry *ce0;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &relation, &method, &record) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(conditions);
array_init(conditions);
PHALCON_INIT_VAR(placeholders);
array_init(placeholders);
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch_string(&r0, relation, SL("fi"), PH_NOISY_CC);
if (Z_TYPE_P(r0) != IS_ARRAY) {
PHALCON_INIT_VAR(field);
phalcon_array_fetch_string(&field, relation, SL("fi"), PH_NOISY_CC);
PHALCON_INIT_VAR(value);
PHALCON_CALL_METHOD_PARAMS_1(value, record, "readattribute", field, PH_NO_CHECK);
PHALCON_INIT_VAR(referenced_field);
phalcon_array_fetch_string(&referenced_field, relation, SL("rf"), PH_NOISY_CC);
PHALCON_INIT_VAR(condition);
PHALCON_CONCAT_VS(condition, referenced_field, " = ?0");
phalcon_array_update_long(&conditions, 0, &condition, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&placeholders, value, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 0);
PHALCON_INIT_VAR(fields);
phalcon_array_fetch_string(&fields, relation, SL("fi"), PH_NOISY_CC);
if (!phalcon_valid_foreach(fields TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(fields);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_74b5_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_74b5_0;
}
PHALCON_INIT_VAR(field);
ZVAL_ZVAL(field, *hd, 1, 0);
PHALCON_INIT_VAR(value);
PHALCON_CALL_METHOD_PARAMS_1(value, record, "readattribute", field, PH_NO_CHECK);
PHALCON_INIT_VAR(r1);
phalcon_array_fetch_string(&r1, relation, SL("rf"), PH_NOISY_CC);
PHALCON_INIT_VAR(referenced_field);
phalcon_array_fetch(&referenced_field, r1, i, PH_NOISY_CC);
PHALCON_INIT_VAR(condition);
PHALCON_CONCAT_VSV(condition, referenced_field, " = ?", i);
phalcon_array_append(&conditions, condition, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&placeholders, value, PH_SEPARATE TSRMLS_CC);
PHALCON_SEPARATE(i);
increment_function(i);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_74b5_0;
fee_74b5_0:
if(0){}
}
PHALCON_INIT_VAR(number_args);
PHALCON_CALL_FUNC(number_args, "func_num_args");
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 4);
PHALCON_ALLOC_ZVAL_MM(r2);
is_smaller_function(r2, t0, number_args TSRMLS_CC);
if (zend_is_true(r2)) {
PHALCON_INIT_VAR(function_arguments);
PHALCON_CALL_FUNC(function_arguments, "func_get_args");
if (!phalcon_valid_foreach(function_arguments TSRMLS_CC)) {
return;
}
ah1 = Z_ARRVAL_P(function_arguments);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
fes_74b5_1:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_74b5_1;
}
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah1, hp1);
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
PHALCON_INIT_VAR(t1);
ZVAL_LONG(t1, 0);
PHALCON_INIT_VAR(r3);
is_equal_function(r3, key, t1 TSRMLS_CC);
PHALCON_INIT_VAR(t2);
ZVAL_STRING(t2, "conditions", 1);
PHALCON_INIT_VAR(r4);
is_equal_function(r4, key, t2 TSRMLS_CC);
PHALCON_INIT_VAR(r5);
ZVAL_BOOL(r5, zend_is_true(r3) || zend_is_true(r4));
if (zend_is_true(r5)) {
phalcon_array_append(&conditions, value, PH_SEPARATE TSRMLS_CC);
}
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_74b5_1;
fee_74b5_1:
if(0){}
}
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, " AND ", 1);
PHALCON_INIT_VAR(join_conditions);
phalcon_fast_join(join_conditions, c0, conditions TSRMLS_CC);
PHALCON_INIT_VAR(find_params);
array_init(find_params);
phalcon_array_append(&find_params, join_conditions, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&find_params, SL("bind"), &placeholders, PH_COPY | PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(arguments);
array_init(arguments);
phalcon_array_append(&arguments, find_params, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(reference_table);
phalcon_array_fetch_string(&reference_table, relation, SL("rt"), PH_NOISY_CC);
ce0 = phalcon_fetch_class(reference_table TSRMLS_CC);
PHALCON_INIT_VAR(referenced_entity);
object_init_ex(referenced_entity, ce0);
PHALCON_CALL_METHOD_NORETURN(referenced_entity, "__construct", PH_CHECK);
PHALCON_ALLOC_ZVAL_MM(r6);
PHALCON_CALL_METHOD(r6, record, "getconnectionservice", PH_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(referenced_entity, "setconnectionservice", r6, PH_NO_CHECK);
PHALCON_INIT_VAR(call_object);
array_init(call_object);
phalcon_array_append(&call_object, referenced_entity, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&call_object, method, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(records);
PHALCON_CALL_FUNC_PARAMS_2(records, "call_user_func_array", call_object, arguments);
RETURN_CCTOR(records);
}
