/** * 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); }