/**
* Sets the query conditions
*
*<code>
* $builder->where('name = "Peter"');
* $builder->where('name = :name: AND id > :id:', array('name' => 'Peter', 'id' => 100));
*</code>
*
* @param string $conditions
* @param array $bindParams
* @param array $bindTypes
* @return Phalcon\Mvc\Model\Query\Builder
*/
PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, where){
zval *conditions, *bind_params = NULL, *bind_types = NULL;
zval *current_bind_params, *merged_params = NULL;
zval *current_bind_types, *merged_types = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 2, &conditions, &bind_params, &bind_types);
if (!bind_params) {
PHALCON_INIT_VAR(bind_params);
}
if (!bind_types) {
PHALCON_INIT_VAR(bind_types);
}
phalcon_update_property_this(this_ptr, SL("_conditions"), conditions TSRMLS_CC);
/**
* Merge the bind params to the current ones
*/
if (Z_TYPE_P(bind_params) == IS_ARRAY) {
PHALCON_OBS_VAR(current_bind_params);
phalcon_read_property_this(¤t_bind_params, this_ptr, SL("_bindParams"), PH_NOISY_CC);
if (Z_TYPE_P(current_bind_params) == IS_ARRAY) {
PHALCON_INIT_VAR(merged_params);
phalcon_add_function(merged_params, bind_params, current_bind_params TSRMLS_CC);
} else {
PHALCON_CPY_WRT(merged_params, bind_params);
}
phalcon_update_property_this(this_ptr, SL("_bindParams"), merged_params TSRMLS_CC);
}
/**
* Merge the bind types to the current ones
*/
if (Z_TYPE_P(bind_types) == IS_ARRAY) {
PHALCON_OBS_VAR(current_bind_types);
phalcon_read_property_this(¤t_bind_types, this_ptr, SL("_bindTypes"), PH_NOISY_CC);
if (Z_TYPE_P(current_bind_types) == IS_ARRAY) {
PHALCON_INIT_VAR(merged_types);
phalcon_add_function(merged_params, bind_types, current_bind_types TSRMLS_CC);
} else {
PHALCON_CPY_WRT(merged_types, bind_types);
}
phalcon_update_property_this(this_ptr, SL("_bindTypes"), merged_types TSRMLS_CC);
}
RETURN_THIS();
}
/**
* Stops the active profile
*
* @return Phalcon\Db\Profiler
*/
PHP_METHOD(Phalcon_Db_Profiler, stopProfile){
zval *final_time = NULL, *active_profile, *initial_time = NULL;
zval *difference, *total_seconds, *new_total_seconds;
PHALCON_MM_GROW();
PHALCON_CALL_FUNCTION(&final_time, "microtime", PHALCON_GLOBAL(z_true));
active_profile = phalcon_fetch_nproperty_this(this_ptr, SL("_activeProfile"), PH_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD(NULL, active_profile, "setfinaltime", final_time);
PHALCON_CALL_METHOD(&initial_time, active_profile, "getinitialtime");
PHALCON_INIT_VAR(difference);
sub_function(difference, final_time, initial_time TSRMLS_CC);
total_seconds = phalcon_fetch_nproperty_this(this_ptr, SL("_totalSeconds"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(new_total_seconds);
phalcon_add_function(new_total_seconds, total_seconds, difference TSRMLS_CC);
phalcon_update_property_this(this_ptr, SL("_totalSeconds"), new_total_seconds TSRMLS_CC);
phalcon_update_property_array_append(this_ptr, SL("_allProfiles"), active_profile TSRMLS_CC);
if (phalcon_method_exists_ex(this_ptr, SS("afterendprofile") TSRMLS_CC) == SUCCESS) {
PHALCON_CALL_METHOD(NULL, this_ptr, "afterendprofile", active_profile);
}
RETURN_THIS();
}
/**
* Sets the bind types
*
* @param array $bindTypes
* @return Phalcon\Mvc\Model\Query\Builder
*/
PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, setBindTypes){
zval *bind_types, *merge = NULL, current_bind_types = {}, merged_types = {};
phalcon_fetch_params(0, 1, 1, &bind_types, &merge);
if (!merge) {
merge = &PHALCON_GLOBAL(z_true);
}
if (zend_is_true(merge)) {
if (Z_TYPE_P(bind_types) == IS_ARRAY) {
phalcon_read_property(¤t_bind_types, getThis(), SL("_bindTypes"), PH_NOISY);
if (Z_TYPE(current_bind_types) == IS_ARRAY) {
phalcon_add_function(&merged_types, bind_types, ¤t_bind_types);
} else {
PHALCON_CPY_WRT(&merged_types, bind_types);
}
phalcon_update_property_zval(getThis(), SL("_bindTypes"), &merged_types);
}
} else {
phalcon_update_property_zval(getThis(), SL("_bindTypes"), bind_types);
}
}
/**
* Stops the active profile
*
* @return Phalcon\Db\Profiler
*/
PHP_METHOD(Phalcon_Db_Profiler, stopProfile){
zval active_profile = {}, final_time = {}, initial_time = {}, difference = {}, total_seconds = {}, new_total_seconds = {};
phalcon_read_property(&active_profile, getThis(), SL("_activeProfile"), PH_NOISY);
PHALCON_CALL_FUNCTIONW(&final_time, "microtime", &PHALCON_GLOBAL(z_true));
PHALCON_CALL_METHODW(NULL, &active_profile, "setfinaltime", &final_time);
PHALCON_CALL_METHODW(&initial_time, &active_profile, "getinitialtime");
phalcon_sub_function(&difference, &final_time, &initial_time);
phalcon_read_property(&total_seconds, getThis(), SL("_totalSeconds"), PH_NOISY);
phalcon_add_function(&new_total_seconds, &total_seconds, &difference);
phalcon_update_property_zval(getThis(), SL("_totalSeconds"), &new_total_seconds);
phalcon_update_property_array_append(getThis(), SL("_allProfiles"), &active_profile);
if (phalcon_method_exists_ex(getThis(), SL("afterendprofile")) == SUCCESS) {
PHALCON_CALL_METHODW(NULL, getThis(), "afterendprofile", &active_profile);
}
RETURN_THISW();
}
/**
* Phalcon\Mvc\Router\Route constructor
*
* @param string $pattern
* @param array $paths
* @param array|string $httpMethods
*/
PHP_METHOD(Phalcon_Mvc_Router_Route, __construct){
zval *pattern, *paths = NULL, *http_methods = NULL, *unique_id = NULL;
zval *route_id = NULL, *one, *next_id;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 2, &pattern, &paths, &http_methods);
if (!paths) {
PHALCON_INIT_VAR(paths);
}
if (!http_methods) {
PHALCON_INIT_VAR(http_methods);
}
/**
* Configure the route (extract parameters, paths, etc)
*/
phalcon_call_method_p2_noret(this_ptr, "reconfigure", pattern, paths);
/**
* Update the HTTP method constraints
*/
phalcon_update_property_this(this_ptr, SL("_methods"), http_methods TSRMLS_CC);
/**
* Get the unique Id from the static member _uniqueId
*/
PHALCON_OBS_VAR(unique_id);
phalcon_read_static_property(&unique_id, SL("phalcon\\mvc\\router\\route"), SL("_uniqueId") TSRMLS_CC);
if (Z_TYPE_P(unique_id) == IS_NULL) {
PHALCON_INIT_NVAR(unique_id);
ZVAL_LONG(unique_id, 0);
}
/**
* TODO: Add a function that increase static members
*/
PHALCON_CPY_WRT(route_id, unique_id);
phalcon_update_property_this(this_ptr, SL("_id"), route_id TSRMLS_CC);
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
PHALCON_INIT_VAR(next_id);
phalcon_add_function(next_id, unique_id, one TSRMLS_CC);
phalcon_update_static_property(SL("phalcon\\mvc\\router\\route"), SL("_uniqueId"), next_id TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Write bytes to the current position in the file pointer
*
* @return Phalcon\Binary\Writer
*/
PHP_METHOD(Phalcon_Binary_Writer, write){
zval *data, *length, position = {}, result = {}, output = {};
phalcon_fetch_params(0, 2, 0, &data, &length);
phalcon_read_property(&position, getThis(), SL("_position"), PH_NOISY);
phalcon_add_function(&result, &position, length);
phalcon_read_property(&output, getThis(), SL("_output"), PH_NOISY);
PHALCON_CALL_FUNCTIONW(return_value, "fwrite", &output, data, length);
phalcon_update_property_zval(getThis(), SL("_position"), &result);
}
/**
* 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();
}
/**
* Stops the active profile
*
* @access public
*/
PHP_METHOD(Phalcon_Db_Profiler, stopProfile){
zval *final_time = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL;
zval *c0 = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_INIT_VAR(c0);
ZVAL_BOOL(c0, 1);
PHALCON_CALL_FUNC_PARAMS_1(r0, "microtime", c0, 0x034);
PHALCON_CPY_WRT(final_time, r0);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_activeProfile", sizeof("_activeProfile")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(t0, "setfinaltime", final_time, PHALCON_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_totalSeconds", sizeof("_totalSeconds")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, "_activeProfile", sizeof("_activeProfile")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD(r1, t2, "getinitialtime", PHALCON_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(r2);
sub_function(r2, final_time, r1 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r3);
phalcon_add_function(r3, t1, r2 TSRMLS_CC);
phalcon_update_property_zval(this_ptr, "_totalSeconds", strlen("_totalSeconds"), r3 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t3);
phalcon_read_property(&t3, this_ptr, "_activeProfile", sizeof("_activeProfile")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t4);
phalcon_read_property(&t4, this_ptr, "_allProfiles", sizeof("_allProfiles")-1, PHALCON_NOISY TSRMLS_CC);
phalcon_array_append(&t4, t3, PHALCON_NO_SEPARATE_THX TSRMLS_CC);
phalcon_update_property_zval(this_ptr, "_allProfiles", strlen("_allProfiles"), t4 TSRMLS_CC);
if (phalcon_method_exists_ex(this_ptr, "afterendprofile", strlen("afterendprofile") TSRMLS_CC) == SUCCESS) {
PHALCON_ALLOC_ZVAL_MM(t5);
phalcon_read_property(&t5, this_ptr, "_activeProfile", sizeof("_activeProfile")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(this_ptr, "afterendprofile", t5, PHALCON_NO_CHECK);
}
PHALCON_MM_RESTORE();
}
/**
* Phalcon\Db constructor
*
* @param stdClass $descriptor
*/
PHP_METHOD(Phalcon_Db, __construct){
zval *descriptor = NULL, *connection_consecutive = NULL;
zval *next_consecutive = NULL, *dialect_type = NULL, *dialect_class = NULL;
zval *dialect_object = NULL;
zval *t0 = NULL;
int eval_int;
zend_class_entry *ce0;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &descriptor) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_OBSERVE_VAR(connection_consecutive);
phalcon_read_static_property(&connection_consecutive, SL("phalcon\\db"), SL("_connectionConsecutive") TSRMLS_CC);
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 1);
PHALCON_INIT_VAR(next_consecutive);
phalcon_add_function(next_consecutive, connection_consecutive, t0 TSRMLS_CC);
phalcon_update_static_property(SL("phalcon\\db"), SL("_connectionConsecutive"), next_consecutive TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_connectionId"), connection_consecutive TSRMLS_CC);
eval_int = phalcon_array_isset_string(descriptor, SL("dialectClass")+1);
if (!eval_int) {
PHALCON_INIT_VAR(dialect_type);
phalcon_read_property(&dialect_type, this_ptr, SL("_dialectType"), PH_NOISY_CC);
PHALCON_INIT_VAR(dialect_class);
PHALCON_CONCAT_SV(dialect_class, "phalcon\\db\\dialect\\", dialect_type);
} else {
PHALCON_INIT_VAR(dialect_class);
phalcon_array_fetch_string(&dialect_class, descriptor, SL("dialectClass"), PH_NOISY_CC);
}
ce0 = phalcon_fetch_class(dialect_class TSRMLS_CC);
PHALCON_INIT_VAR(dialect_object);
object_init_ex(dialect_object, ce0);
PHALCON_CALL_METHOD_NORETURN(dialect_object, "__construct", PH_CHECK);
phalcon_update_property_zval(this_ptr, SL("_dialect"), dialect_object TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_descriptor"), descriptor TSRMLS_CC);
PHALCON_MM_RESTORE();
}
PHP_METHOD(Phalcon_Internal_TestParent, smp3){
zval *v0 = NULL, *v1 = NULL;
zval *r0 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &v0, &v1) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_add_function(r0, v0, v1 TSRMLS_CC);
PHALCON_RETURN_CTOR(r0);
}
PHP_METHOD(Phalcon_Internal_TestParent, mp2){
zval *v0 = NULL, *v1 = NULL;
zval *r0 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &v0, &v1) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
phalcon_update_property_long(this_ptr, "_pp0", strlen("_pp0"), 0 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_add_function(r0, v0, v1 TSRMLS_CC);
PHALCON_RETURN_CTOR(r0);
}
/**
* Stops the active profile
*
* @return Phalcon\Db\Profiler
*/
PHP_METHOD(Phalcon_Db_Profiler, stopProfile){
zval *micro, *final_time, *active_profile, *initial_time;
zval *diference, *total_seconds, *new_total_seconds;
zval *t0 = NULL;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(micro);
ZVAL_BOOL(micro, 1);
PHALCON_INIT_VAR(final_time);
PHALCON_CALL_FUNC_PARAMS_1(final_time, "microtime", micro);
PHALCON_INIT_VAR(active_profile);
phalcon_read_property(&active_profile, this_ptr, SL("_activeProfile"), PH_NOISY_CC);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(active_profile, "setfinaltime", final_time, PH_NO_CHECK);
PHALCON_INIT_VAR(initial_time);
PHALCON_CALL_METHOD(initial_time, active_profile, "getinitialtime", PH_NO_CHECK);
PHALCON_INIT_VAR(diference);
sub_function(diference, final_time, initial_time TSRMLS_CC);
PHALCON_INIT_VAR(total_seconds);
phalcon_read_property(&total_seconds, this_ptr, SL("_totalSeconds"), PH_NOISY_CC);
PHALCON_INIT_VAR(new_total_seconds);
phalcon_add_function(new_total_seconds, total_seconds, diference TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_totalSeconds"), new_total_seconds TSRMLS_CC);
PHALCON_INIT_VAR(t0);
phalcon_read_property(&t0, this_ptr, SL("_allProfiles"), PH_NOISY_CC);
phalcon_array_append(&t0, active_profile, 0 TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_allProfiles"), t0 TSRMLS_CC);
if (phalcon_method_exists_ex(this_ptr, SS("afterendprofile") TSRMLS_CC) == SUCCESS) {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(this_ptr, "afterendprofile", active_profile, PH_NO_CHECK);
}
RETURN_CTOR(this_ptr);
}
/**
* Stops the active profile
*
* @return Phalcon\Db\Profiler
*/
PHP_METHOD(Phalcon_Db_Profiler, stopProfile){
zval *micro, *final_time, *active_profile, *initial_time;
zval *diference, *total_seconds, *new_total_seconds;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(micro);
ZVAL_BOOL(micro, 1);
PHALCON_INIT_VAR(final_time);
phalcon_call_func_p1(final_time, "microtime", micro);
PHALCON_OBS_VAR(active_profile);
phalcon_read_property_this(&active_profile, this_ptr, SL("_activeProfile"), PH_NOISY_CC);
phalcon_call_method_p1_noret(active_profile, "setfinaltime", final_time);
PHALCON_INIT_VAR(initial_time);
phalcon_call_method(initial_time, active_profile, "getinitialtime");
PHALCON_INIT_VAR(diference);
sub_function(diference, final_time, initial_time TSRMLS_CC);
PHALCON_OBS_VAR(total_seconds);
phalcon_read_property_this(&total_seconds, this_ptr, SL("_totalSeconds"), PH_NOISY_CC);
PHALCON_INIT_VAR(new_total_seconds);
phalcon_add_function(new_total_seconds, total_seconds, diference TSRMLS_CC);
phalcon_update_property_this(this_ptr, SL("_totalSeconds"), new_total_seconds TSRMLS_CC);
phalcon_update_property_array_append(this_ptr, SL("_allProfiles"), active_profile TSRMLS_CC);
if (phalcon_method_exists_ex(this_ptr, SS("afterendprofile") TSRMLS_CC) == SUCCESS) {
phalcon_call_method_p1_noret(this_ptr, "afterendprofile", active_profile);
}
RETURN_THIS();
}
/**
* Produces a recursive representation of an array
*
* @param array $argument
* @return string
*/
PHP_METHOD(Phalcon_Debug, _getArrayDump){
zval *argument, *n = NULL, *number_arguments, *one, *dump;
zval *v = NULL, *k = NULL, *var_dump = NULL, *escaped_string = NULL, *next = NULL, *array_dump = NULL;
zval *class_name = NULL, *joined_dump;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &argument, &n);
if (!n) {
PHALCON_INIT_VAR(n);
ZVAL_LONG(n, 0);
}
PHALCON_INIT_VAR(number_arguments);
phalcon_fast_count(number_arguments, argument TSRMLS_CC);
if (PHALCON_LT_LONG(n, 3)) {
if (PHALCON_GT_LONG(number_arguments, 0)) {
if (PHALCON_LT_LONG(number_arguments, 10)) {
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
PHALCON_INIT_VAR(dump);
array_init(dump);
phalcon_is_iterable(argument, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(k, ah0, hp0);
PHALCON_GET_HVALUE(v);
if (PHALCON_IS_SCALAR(v)) {
if (PHALCON_IS_STRING(v, "")) {
PHALCON_INIT_NVAR(var_dump);
PHALCON_CONCAT_SVS(var_dump, "[", k, "] => (empty string)");
} else {
PHALCON_INIT_NVAR(escaped_string);
phalcon_call_method_p1(escaped_string, this_ptr, "_escapestring", v);
PHALCON_INIT_NVAR(var_dump);
PHALCON_CONCAT_SVSV(var_dump, "[", k, "] => ", escaped_string);
}
phalcon_array_append(&dump, var_dump, PH_SEPARATE);
} else {
if (Z_TYPE_P(v) == IS_ARRAY) {
PHALCON_INIT_NVAR(next);
phalcon_add_function(next, n, one TSRMLS_CC);
PHALCON_INIT_NVAR(array_dump);
phalcon_call_method_p2(array_dump, this_ptr, "_getarraydump", v, next);
PHALCON_INIT_NVAR(var_dump);
PHALCON_CONCAT_SVSVS(var_dump, "[", k, "] => Array(", array_dump, ")");
phalcon_array_append(&dump, var_dump, PH_SEPARATE);
zend_hash_move_forward_ex(ah0, &hp0);
continue;
}
if (Z_TYPE_P(v) == IS_OBJECT) {
PHALCON_INIT_NVAR(class_name);
phalcon_get_class(class_name, v, 0 TSRMLS_CC);
PHALCON_INIT_NVAR(var_dump);
PHALCON_CONCAT_SVSVS(var_dump, "[", k, "] => Object(", class_name, ")");
phalcon_array_append(&dump, var_dump, PH_SEPARATE);
zend_hash_move_forward_ex(ah0, &hp0);
continue;
}
if (Z_TYPE_P(v) == IS_NULL) {
PHALCON_INIT_NVAR(var_dump);
PHALCON_CONCAT_SVS(var_dump, "[", k, "] => null");
phalcon_array_append(&dump, var_dump, PH_SEPARATE);
zend_hash_move_forward_ex(ah0, &hp0);
continue;
}
PHALCON_INIT_NVAR(var_dump);
PHALCON_CONCAT_SVSV(var_dump, "[", k, "] => ", v);
phalcon_array_append(&dump, var_dump, PH_SEPARATE);
}
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_VAR(joined_dump);
phalcon_fast_join_str(joined_dump, SL(", "), dump TSRMLS_CC);
RETURN_CTOR(joined_dump);
}
RETURN_NCTOR(number_arguments);
}
}
RETURN_MM_NULL();
}
/**
* 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);
}
/**
* 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);
}
/**
* Produces a recursive representation of an array
*
* @param array $argument
* @return string
*/
PHP_METHOD(Phalcon_Debug, _getArrayDump) {
zval *argument, *n = NULL, *number_arguments, *dump;
zval *v = NULL, *var_dump = NULL, *escaped_string = NULL, *next = NULL, *array_dump = NULL;
zval *class_name = NULL, *joined_dump;
zend_string *str_key;
ulong idx;
PHALCON_MM_GROW();
phalcon_fetch_params(0, 1, 1, &argument, &n);
if (!n) {
PHALCON_INIT_VAR(n);
ZVAL_LONG(n, 0);
}
PHALCON_INIT_VAR(number_arguments);
phalcon_fast_count(number_arguments, argument);
if (PHALCON_LT_LONG(n, 3)) {
if (PHALCON_GT_LONG(number_arguments, 0)) {
if (PHALCON_LT_LONG(number_arguments, 10)) {
PHALCON_INIT_VAR(dump);
array_init(dump);
ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(argument), idx, str_key, v) {
zval tmp;
if (str_key) {
ZVAL_STR(&tmp, str_key);
} else {
ZVAL_LONG(&tmp, idx);
}
if (PHALCON_IS_SCALAR(v)) {
if (PHALCON_IS_STRING(v, "")) {
PHALCON_INIT_NVAR(var_dump);
PHALCON_CONCAT_SVS(var_dump, "[", &tmp, "] => (empty string)");
} else {
PHALCON_CALL_METHOD(&escaped_string, getThis(), "_escapestring", v);
PHALCON_INIT_NVAR(var_dump);
PHALCON_CONCAT_SVSV(var_dump, "[", &tmp, "] => ", escaped_string);
}
phalcon_array_append(dump, var_dump, PH_COPY);
} else {
if (Z_TYPE_P(v) == IS_ARRAY) {
PHALCON_INIT_NVAR(next);
phalcon_add_function(next, n, &PHALCON_GLOBAL(z_one));
PHALCON_CALL_METHOD(&array_dump, getThis(), "_getarraydump", v, next);
PHALCON_INIT_NVAR(var_dump);
PHALCON_CONCAT_SVSVS(var_dump, "[", &tmp, "] => Array(", array_dump, ")");
phalcon_array_append(dump, var_dump, PH_COPY);
continue;
}
if (Z_TYPE_P(v) == IS_OBJECT) {
zend_class_entry *ce = Z_OBJCE_P(v);
PHALCON_INIT_NVAR(class_name);
ZVAL_NEW_STR(class_name, ce->name);
PHALCON_INIT_NVAR(var_dump);
PHALCON_CONCAT_SVSVS(var_dump, "[", &tmp, "] => Object(", class_name, ")");
phalcon_array_append(dump, var_dump, PH_COPY);
continue;
}
if (Z_TYPE_P(v) == IS_NULL) {
PHALCON_INIT_NVAR(var_dump);
PHALCON_CONCAT_SVS(var_dump, "[", &tmp, "] => null");
phalcon_array_append(dump, var_dump, PH_COPY);
continue;
}
PHALCON_INIT_NVAR(var_dump);
PHALCON_CONCAT_SVSV(var_dump, "[", &tmp, "] => ", v);
phalcon_array_append(dump, var_dump, PH_COPY);
}
}
ZEND_HASH_FOREACH_END();
PHALCON_INIT_VAR(joined_dump);
phalcon_fast_join_str(joined_dump, SL(", "), dump);
RETURN_CTOR(joined_dump);
}
RETURN_NCTOR(number_arguments);
}
/**
* Returns a slice of the resultset to show in the pagination
*
* @return \stdClass
*/
PHP_METHOD(Phalcon_Paginator_Adapter_Model, getPaginate) {
zval show = {}, config = {}, items = {}, page_number = {}, rowcount = {}, page = {}, last_show_page = {}, start = {}, possible_pages = {}, total_pages = {};
zval page_items = {}, maximum_pages = {}, next = {}, additional_page = {}, before = {}, remainder = {}, pages_total = {};
long int i, i_show;
phalcon_return_property(&show, getThis(), SL("_limitRows"));
phalcon_return_property(&config, getThis(), SL("_config"));
phalcon_return_property(&page_number, getThis(), SL("_page"));
i_show = phalcon_get_intval(&show);
phalcon_array_fetch_str(&items, &config, SL("data"), PH_NOISY);
if (Z_TYPE(page_number) == IS_NULL || PHALCON_LT(&show, &PHALCON_GLOBAL(z_zero))) {
PHALCON_CPY_WRT_CTOR(&page_number, &PHALCON_GLOBAL(z_one));
}
phalcon_fast_count(&rowcount, &items);
object_init(&page);
phalcon_sub_function(&last_show_page, &page_number, &PHALCON_GLOBAL(z_one));
mul_function(&start, &show, &last_show_page);
phalcon_div_function(&possible_pages, &rowcount, &show);
if (unlikely(Z_TYPE(possible_pages)) != IS_DOUBLE) {
convert_to_double(&possible_pages);
}
ZVAL_LONG(&total_pages, (long int)ceil(Z_DVAL(possible_pages)));
if (Z_TYPE(items) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_paginator_exception_ce, "Invalid data for paginator");
return;
}
array_init(&page_items);
if (PHALCON_GT(&rowcount, &PHALCON_GLOBAL(z_zero))) {
/**
* Seek to the desired position
*/
if (PHALCON_LT(&start, &rowcount)) {
PHALCON_CALL_METHODW(NULL, &items, "seek", &start);
} else {
PHALCON_CALL_METHODW(NULL, &items, "rewind");
PHALCON_CPY_WRT_CTOR(&page_number, &PHALCON_GLOBAL(z_one));
PHALCON_CPY_WRT_CTOR(&start, &PHALCON_GLOBAL(z_zero));
}
/**
* The record must be iterable
*/
for (i=1; ; ++i) {
zval valid = {}, current = {};
PHALCON_CALL_METHODW(&valid, &items, "valid");
if (!PHALCON_IS_NOT_FALSE(&valid)) {
break;
}
PHALCON_CALL_METHODW(¤t, &items, "current");
phalcon_array_append(&page_items, ¤t, PH_COPY);
if (i >= i_show) {
break;
}
}
}
phalcon_update_property_zval(&page, SL("items"), &page_items);
phalcon_add_function(&maximum_pages, &start, &show);
if (PHALCON_LT(&maximum_pages, &rowcount)) {
phalcon_add_function(&next, &page_number, &PHALCON_GLOBAL(z_one));
} else if (PHALCON_IS_EQUAL(&maximum_pages, &rowcount)) {
PHALCON_CPY_WRT_CTOR(&next, &rowcount);
} else {
phalcon_div_function(&possible_pages, &rowcount, &show);
phalcon_add_function(&additional_page, &possible_pages, &PHALCON_GLOBAL(z_one));
ZVAL_LONG(&next, phalcon_get_intval(&additional_page));
}
if (PHALCON_GT(&next, &total_pages)) {
PHALCON_CPY_WRT_CTOR(&next, &total_pages);
}
phalcon_update_property_zval(&page, SL("next"), &next);
if (PHALCON_GT(&page_number, &PHALCON_GLOBAL(z_one))) {
phalcon_sub_function(&before, &page_number, &PHALCON_GLOBAL(z_one));
} else {
PHALCON_CPY_WRT_CTOR(&before, &PHALCON_GLOBAL(z_one));
}
phalcon_update_property_zval(&page, SL("first"), &PHALCON_GLOBAL(z_one));
phalcon_update_property_zval(&page, SL("before"), &before);
phalcon_update_property_zval(&page, SL("current"), &page_number);
mod_function(&remainder, &rowcount, &show);
phalcon_div_function(&possible_pages, &rowcount, &show);
if (!PHALCON_IS_LONG(&remainder, 0)) {
phalcon_add_function(&next, &possible_pages, &PHALCON_GLOBAL(z_one));
ZVAL_LONG(&pages_total, phalcon_get_intval(&next));
} else {
PHALCON_CPY_WRT_CTOR(&pages_total, &possible_pages);
}
phalcon_update_property_zval(&page, SL("last"), &pages_total);
phalcon_update_property_zval(&page, SL("total_pages"), &pages_total);
phalcon_update_property_zval(&page, SL("total_items"), &rowcount);
RETURN_CTORW(&page);
}
/**
* 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);
}
/**
* Executes a prepared statement binding
*
* @param PDOStatement $statement
* @param array $placeholders
* @param array $dataTypes
* @return PDOStatement
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, _executePrepared){
zval *statement = NULL, *placeholders = NULL, *data_types = NULL;
zval *one = NULL, *value = NULL, *wildcard = NULL, *parameter = NULL, *type = NULL, *cast_value = 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, "zzz", &statement, &placeholders, &data_types) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
if (!phalcon_valid_foreach(placeholders TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(placeholders);
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_INIT_VAR(wildcard);
PHALCON_GET_FOREACH_KEY(wildcard, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(value);
if (Z_TYPE_P(wildcard) == IS_LONG) {
PHALCON_INIT_VAR(parameter);
phalcon_add_function(parameter, wildcard, one TSRMLS_CC);
} else {
if (Z_TYPE_P(wildcard) == IS_STRING) {
PHALCON_CPY_WRT(parameter, wildcard);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind parameter");
return;
}
}
if (Z_TYPE_P(data_types) == IS_ARRAY) {
eval_int = phalcon_array_isset(data_types, wildcard);
if (eval_int) {
PHALCON_INIT_VAR(type);
phalcon_array_fetch(&type, data_types, wildcard, PH_NOISY_CC);
if (phalcon_compare_strict_long(type, 32 TSRMLS_CC)) {
PHALCON_INIT_VAR(cast_value);
PHALCON_CALL_FUNC_PARAMS_1(cast_value, "doubleval", value);
PHALCON_INIT_VAR(type);
ZVAL_LONG(type, 2);
} else {
PHALCON_CPY_WRT(cast_value, value);
}
Z_SET_ISREF_P(cast_value);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(statement, "bindparam", parameter, cast_value, type, PH_NO_CHECK);
Z_UNSET_ISREF_P(cast_value);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind type parameter");
return;
}
} else {
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(statement, "bindparam", parameter, value, PH_NO_CHECK);
}
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
PHALCON_CALL_METHOD_NORETURN(statement, "execute", PH_NO_CHECK);
RETURN_CCTOR(statement);}
/**
* Executes a prepared statement binding. This function uses integer indexes starting from zero
*
*<code>
* $statement = $db->prepare('SELECT * FROM robots WHERE name = :name');
* $result = $connection->executePrepared($statement, array('name' => 'Voltron'));
*</code>
*
* @param \PDOStatement $statement
* @param array $placeholders
* @param array $dataTypes
* @return \PDOStatement
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, executePrepared){
zval *statement = NULL, *placeholders = NULL, *data_types = NULL;
zval *one, *value = NULL, *wildcard = NULL, *parameter = NULL, *type = NULL, *cast_value = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &statement, &placeholders, &data_types) == FAILURE) {
RETURN_MM_NULL();
}
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
if (!phalcon_is_iterable_ex(placeholders, &ah0, &hp0, 0, 0)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(wildcard, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(value);
if (Z_TYPE_P(wildcard) == IS_LONG) {
PHALCON_INIT_NVAR(parameter);
phalcon_add_function(parameter, wildcard, one TSRMLS_CC);
} else {
if (Z_TYPE_P(wildcard) == IS_STRING) {
PHALCON_CPY_WRT(parameter, wildcard);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind parameter");
return;
}
}
if (Z_TYPE_P(data_types) == IS_ARRAY) {
if (likely(phalcon_array_isset(data_types, wildcard))) {
/**
* The bind type is double so we try to get the double value
*/
PHALCON_OBS_NVAR(type);
phalcon_array_fetch(&type, data_types, wildcard, PH_NOISY);
if (phalcon_compare_strict_long(type, 32 TSRMLS_CC)) {
PHALCON_INIT_NVAR(cast_value);
phalcon_cast(cast_value, value, IS_DOUBLE);
PHALCON_INIT_NVAR(type);
ZVAL_LONG(type, 1024);
} else {
PHALCON_CPY_WRT(cast_value, value);
}
/**
* 1024 is ignore the bind type
*/
Z_SET_ISREF_P(cast_value);
if (phalcon_compare_strict_long(type, 1024 TSRMLS_CC)) {
phalcon_call_method_p2_noret(statement, "bindparam", parameter, cast_value);
} else {
phalcon_call_method_p3_noret(statement, "bindparam", parameter, cast_value, type);
}
Z_UNSET_ISREF_P(cast_value);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind type parameter");
return;
}
} else {
Z_SET_ISREF_P(value);
phalcon_call_method_p2_noret(statement, "bindparam", parameter, value);
Z_UNSET_ISREF_P(value);
}
zend_hash_move_forward_ex(ah0, &hp0);
}
phalcon_call_method_noret(statement, "execute");
RETURN_CCTOR(statement);
}
/**
* Stores cached content into the Mongo backend and stops the frontend
*
* @param int|string $keyName
* @param string $content
* @param long $lifetime
* @param boolean $stopBuffer
*/
PHP_METHOD(Phalcon_Cache_Backend_Mongo, save){
zval *key_name = NULL, *content = NULL, *lifetime = NULL, *stop_buffer = NULL;
zval *last_key = NULL, *prefix, *frontend, *cached_content = NULL;
zval *prepared_content, *ttl = NULL, *collection, *timestamp;
zval *conditions, *document, *data, *is_buffering;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 4, &key_name, &content, &lifetime, &stop_buffer);
if (!key_name) {
PHALCON_INIT_VAR(key_name);
}
if (!content) {
PHALCON_INIT_VAR(content);
}
if (!lifetime) {
PHALCON_INIT_VAR(lifetime);
}
if (!stop_buffer) {
PHALCON_INIT_VAR(stop_buffer);
ZVAL_BOOL(stop_buffer, 1);
}
if (Z_TYPE_P(key_name) == IS_NULL) {
PHALCON_OBS_VAR(last_key);
phalcon_read_property_this(&last_key, this_ptr, SL("_lastKey"), PH_NOISY_CC);
} else {
PHALCON_OBS_VAR(prefix);
phalcon_read_property_this(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC);
PHALCON_INIT_NVAR(last_key);
PHALCON_CONCAT_VV(last_key, prefix, key_name);
}
if (!zend_is_true(last_key)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The cache must be started first");
return;
}
PHALCON_OBS_VAR(frontend);
phalcon_read_property_this(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC);
if (Z_TYPE_P(content) == IS_NULL) {
PHALCON_INIT_VAR(cached_content);
phalcon_call_method(cached_content, frontend, "getcontent");
} else {
PHALCON_CPY_WRT(cached_content, content);
}
PHALCON_INIT_VAR(prepared_content);
phalcon_call_method_p1(prepared_content, frontend, "beforestore", cached_content);
if (Z_TYPE_P(lifetime) == IS_NULL) {
PHALCON_INIT_VAR(ttl);
phalcon_call_method(ttl, frontend, "getlifetime");
} else {
PHALCON_CPY_WRT(ttl, lifetime);
}
PHALCON_INIT_VAR(collection);
phalcon_call_method(collection, this_ptr, "_getcollection");
PHALCON_INIT_VAR(timestamp);
ZVAL_LONG(timestamp, (long) time(NULL));
PHALCON_INIT_NVAR(ttl);
phalcon_add_function(ttl, lifetime, timestamp TSRMLS_CC);
PHALCON_INIT_VAR(conditions);
array_init_size(conditions, 1);
phalcon_array_update_string(&conditions, SL("key"), &last_key, PH_COPY | PH_SEPARATE);
PHALCON_INIT_VAR(document);
phalcon_call_method_p1(document, collection, "findone", conditions);
if (Z_TYPE_P(document) == IS_ARRAY) {
phalcon_array_update_string(&document, SL("time"), &ttl, PH_COPY | PH_SEPARATE);
phalcon_array_update_string(&document, SL("data"), &prepared_content, PH_COPY | PH_SEPARATE);
phalcon_call_method_p1_noret(collection, "save", document);
} else {
PHALCON_INIT_VAR(data);
array_init_size(data, 3);
phalcon_array_update_string(&data, SL("key"), &last_key, PH_COPY | PH_SEPARATE);
phalcon_array_update_string(&data, SL("time"), &ttl, PH_COPY | PH_SEPARATE);
phalcon_array_update_string(&data, SL("data"), &prepared_content, PH_COPY | PH_SEPARATE);
phalcon_call_method_p1_noret(collection, "save", data);
}
PHALCON_INIT_VAR(is_buffering);
phalcon_call_method(is_buffering, frontend, "isbuffering");
if (PHALCON_IS_TRUE(stop_buffer)) {
phalcon_call_method_noret(frontend, "stop");
}
if (PHALCON_IS_TRUE(is_buffering)) {
zend_print_zval(cached_content, 0);
}
phalcon_update_property_bool(this_ptr, SL("_started"), 0 TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Returns a slice of the resultset to show in the pagination
*
* @return stdClass
*/
PHP_METHOD(Phalcon_Paginator_Adapter_NativeArray, getPaginate){
zval *one, *config, *items, *show, *page_number = NULL, *page;
zval *number, *rounded_total, *total_pages, *before_page_number;
zval *start, *slice, *compare = NULL, *next = NULL, *before = NULL;
PHALCON_MM_GROW();
/**
* TODO: Rewrite the whole method!
*/
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
PHALCON_OBS_VAR(config);
phalcon_read_property_this(&config, this_ptr, SL("_config"), PH_NOISY_CC);
PHALCON_OBS_VAR(items);
phalcon_array_fetch_string(&items, config, SL("data"), PH_NOISY_CC);
if (Z_TYPE_P(items) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_paginator_exception_ce, "Invalid data for paginator");
return;
}
PHALCON_OBS_VAR(show);
phalcon_read_property_this(&show, this_ptr, SL("_limitRows"), PH_NOISY_CC);
PHALCON_OBS_VAR(page_number);
phalcon_read_property_this(&page_number, this_ptr, SL("_page"), PH_NOISY_CC);
if (!zend_is_true(page_number)) {
PHALCON_CPY_WRT(page_number, one);
}
PHALCON_INIT_VAR(page);
object_init(page);
PHALCON_INIT_VAR(number);
phalcon_fast_count(number, items TSRMLS_CC);
PHALCON_INIT_VAR(rounded_total);
div_function(rounded_total, number, show TSRMLS_CC);
PHALCON_INIT_VAR(total_pages);
PHALCON_CALL_FUNC_PARAMS_1(total_pages, "intval", rounded_total);
/**
* Increase total_pages if wasn't integer
*/
if (!PHALCON_IS_EQUAL(total_pages, rounded_total)) {
PHALCON_SEPARATE_NMO(total_pages);
increment_function(total_pages);
}
PHALCON_INIT_VAR(before_page_number);
sub_function(before_page_number, page_number, one TSRMLS_CC);
PHALCON_INIT_VAR(start);
mul_function(start, show, before_page_number TSRMLS_CC);
PHALCON_INIT_VAR(slice);
PHALCON_CALL_FUNC_PARAMS_3(slice, "array_slice", items, start, show);
phalcon_update_property_zval(page, SL("items"), slice TSRMLS_CC);
PHALCON_INIT_VAR(compare);
is_smaller_function(compare, page_number, total_pages TSRMLS_CC);
if (PHALCON_IS_TRUE(compare)) {
PHALCON_INIT_VAR(next);
phalcon_add_function(next, page_number, one TSRMLS_CC);
} else {
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("first"), one TSRMLS_CC);
phalcon_update_property_zval(page, SL("before"), before TSRMLS_CC);
phalcon_update_property_zval(page, SL("current"), page_number TSRMLS_CC);
phalcon_update_property_zval(page, SL("last"), total_pages TSRMLS_CC);
phalcon_update_property_zval(page, SL("total_pages"), total_pages TSRMLS_CC);
phalcon_update_property_zval(page, SL("total_items"), number TSRMLS_CC);
RETURN_CTOR(page);
}
/**
* Add a route to the router
*
* @param string $pattern
* @param string/array $paths
*/
PHP_METHOD(Phalcon_Mvc_Router, add){
zval *pattern = NULL, *paths = NULL, *parts = NULL, *route_paths = NULL, *pcre_pattern = NULL;
zval *matches = NULL, *match = NULL, *n = NULL;
zval *c0 = NULL, *c1 = NULL, *c2 = 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;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL;
zval *a0 = NULL;
zval *p0[] = { 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, "zz", &pattern, &paths) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(paths) == IS_STRING) {
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "::", 1);
PHALCON_INIT_VAR(parts);
phalcon_fast_explode(parts, c0, paths TSRMLS_CC);
PHALCON_INIT_VAR(route_paths);
array_init(route_paths);
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch_long(&r0, parts, 0, PH_NOISY_CC);
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_FUNC_PARAMS_1(r1, "strtolower", r0);
phalcon_array_update_string(&route_paths, SL("controller"), &r1, PH_COPY | PH_SEPARATE TSRMLS_CC);
eval_int = phalcon_array_isset_long(parts, 1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r2);
phalcon_array_fetch_long(&r2, parts, 1, PH_NOISY_CC);
phalcon_array_update_string(&route_paths, SL("action"), &r2, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
} else {
PHALCON_CPY_WRT(route_paths, paths);
}
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, "#", 1);
PHALCON_INIT_VAR(c2);
ZVAL_STRING(c2, "\\#", 1);
PHALCON_INIT_VAR(pcre_pattern);
phalcon_fast_str_replace(pcre_pattern, c1, c2, pattern TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r3);
phalcon_fast_strpos_str(r3, pcre_pattern, SL("{") TSRMLS_CC);
if (zend_is_true(r3)) {
PHALCON_INIT_VAR(matches);
array_init(matches);
PHALCON_INIT_VAR(p0[0]);
ZVAL_STRING(p0[0], "#{([a-zA-Z0-9\\_\\-]+):([^}]+)}#", 1);
p0[1] = pcre_pattern;
Z_SET_ISREF_P(matches);
p0[2] = matches;
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 2);
p0[3] = t0;
PHALCON_ALLOC_ZVAL_MM(r4);
PHALCON_CALL_FUNC_PARAMS(r4, "preg_match_all", 4, p0);
Z_UNSET_ISREF_P(p0[2]);
if (zend_is_true(r4)) {
if (!phalcon_valid_foreach(matches TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(matches);
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(n);
PHALCON_GET_FOREACH_KEY(n, ah0, hp0);
PHALCON_INIT_VAR(match);
ZVAL_ZVAL(match, *hd, 1, 0);
PHALCON_INIT_VAR(r5);
phalcon_array_fetch_long(&r5, match, 0, PH_NOISY_CC);
PHALCON_INIT_VAR(r6);
phalcon_array_fetch_long(&r6, match, 2, PH_NOISY_CC);
PHALCON_INIT_VAR(r7);
PHALCON_CONCAT_SVS(r7, "(", r6, ")");
PHALCON_INIT_VAR(r8);
phalcon_fast_str_replace(r8, r5, r7, pcre_pattern TSRMLS_CC);
PHALCON_CPY_WRT(pcre_pattern, r8);
PHALCON_INIT_VAR(t1);
ZVAL_LONG(t1, 1);
PHALCON_INIT_VAR(r9);
phalcon_add_function(r9, n, t1 TSRMLS_CC);
PHALCON_INIT_VAR(r10);
phalcon_array_fetch_long(&r10, match, 1, PH_NOISY_CC);
phalcon_array_update_zval(&route_paths, r10, &r9, PH_COPY | PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_c9ff_0;
fee_c9ff_0:
if(0){}
}
}
PHALCON_ALLOC_ZVAL_MM(a0);
array_init(a0);
PHALCON_ALLOC_ZVAL_MM(r11);
PHALCON_CALL_METHOD_PARAMS_1(r11, this_ptr, "compilepattern", pcre_pattern, PH_NO_CHECK);
phalcon_array_update_string(&a0, SL("pattern"), &r11, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&a0, SL("paths"), &route_paths, PH_COPY | PH_SEPARATE TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, SL("_routes"), PH_NOISY_CC);
phalcon_array_append(&t2, a0, 0 TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_routes"), t2 TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* 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);
}
/**
* Executes a prepared statement binding. This function uses integer indexes starting from zero
*
*<code>
* $statement = $connection->prepare('SELECT * FROM robots WHERE name = :name');
* $pdoResult = $connection->executePrepared($statement, array('name' => 'Voltron'));
*</code>
*
* @param \PDOStatement $statement
* @param array $placeholders
* @param array $dataTypes
* @return \PDOStatement
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, executePrepared){
zval *statement = NULL, *placeholders = NULL, *data_types = NULL;
zval *z_one, *value = NULL, *wildcard = NULL, *parameter = NULL, *type = NULL, *cast_value = NULL;
zval *profiler, *sql_statement;
HashTable *ah0;
HashPosition hp0;
zval **hd;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &statement, &placeholders, &data_types) == FAILURE) {
RETURN_NULL();
}
PHALCON_MM_GROW();
z_one = PHALCON_GLOBAL(z_one);
phalcon_is_iterable(placeholders, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(wildcard, ah0, hp0);
PHALCON_GET_HVALUE(value);
if (Z_TYPE_P(wildcard) == IS_LONG) {
PHALCON_INIT_NVAR(parameter);
phalcon_add_function(parameter, wildcard, z_one);
} else {
if (Z_TYPE_P(wildcard) == IS_STRING) {
PHALCON_CPY_WRT(parameter, wildcard);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind parameter");
return;
}
}
if (Z_TYPE_P(data_types) == IS_ARRAY) {
if (likely(phalcon_array_isset(data_types, wildcard))) {
/**
* The bind type is double so we try to get the double value
*/
PHALCON_OBS_NVAR(type);
phalcon_array_fetch(&type, data_types, wildcard, PH_NOISY);
if (phalcon_compare_strict_long(type, 32 TSRMLS_CC)) {
PHALCON_INIT_NVAR(cast_value);
phalcon_cast(cast_value, value, IS_DOUBLE);
PHALCON_INIT_NVAR(type);
ZVAL_LONG(type, 1024);
} else {
PHALCON_CPY_WRT(cast_value, value);
}
/**
* 1024 is ignore the bind type
*/
Z_SET_ISREF_P(cast_value);
if (phalcon_compare_strict_long(type, 1024 TSRMLS_CC)) {
PHALCON_CALL_METHOD(NULL, statement, "bindvalue", parameter, cast_value);
} else {
PHALCON_CALL_METHOD(NULL, statement, "bindvalue", parameter, cast_value, type);
}
Z_UNSET_ISREF_P(cast_value);
} else {
PHALCON_INIT_NVAR(type);
if (Z_TYPE_P(value) == IS_LONG) {
ZVAL_LONG(type, 1 /* BIND_PARAM_INT */);
}
else {
ZVAL_LONG(type, 2 /* BIND_PARAM_STR */);
}
Z_SET_ISREF_P(value);
PHALCON_CALL_METHOD(NULL, statement, "bindvalue", parameter, value, type);
Z_UNSET_ISREF_P(value);
/*
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind type parameter");
return;
*/
}
} else {
Z_SET_ISREF_P(value);
PHALCON_CALL_METHOD(NULL, statement, "bindvalue", parameter, value);
Z_UNSET_ISREF_P(value);
}
zend_hash_move_forward_ex(ah0, &hp0);
}
profiler = phalcon_fetch_nproperty_this(this_ptr, SL("_profiler"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(profiler) == IS_OBJECT) {
sql_statement = phalcon_fetch_nproperty_this(this_ptr, SL("_sqlStatement"), PH_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD(NULL, profiler, "startprofile", sql_statement, placeholders, data_types);
PHALCON_CALL_METHOD(NULL, statement, "execute");
PHALCON_CALL_METHOD(NULL, profiler, "stopprofile");
} else {
PHALCON_CALL_METHOD(NULL, statement, "execute");
}
RETURN_CTOR(statement);
}
PHP_METHOD(Phalcon_Test, nice){
zval *v0 = NULL, *v1 = NULL, *v2 = NULL, *v3 = NULL;
zval *a0 = NULL;
zval *r0 = NULL, *r1 = NULL;
zval *t0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *index;
uint index_len;
ulong num;
int htype;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &v0) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(a0);
array_init(a0);
add_assoc_long_ex(a0, "hello1", strlen("hello1")+1, 1);
add_assoc_long_ex(a0, "hello2", strlen("hello2")+1, 2);
add_assoc_long_ex(a0, "hello3", strlen("hello3")+1, 3);
PHALCON_CPY_WRT(v1, a0);
if (Z_TYPE_P(v1) != IS_ARRAY) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid argument supplied for foreach()");
} else {
ALLOC_HASHTABLE(ah0);
zend_hash_init(ah0, 0, NULL, NULL, 0);
zend_hash_copy(ah0, Z_ARRVAL_P(v1), NULL, NULL, sizeof(zval*));
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_2ebb_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_2ebb_0;
} else {
PHALCON_INIT_VAR(v3);
htype = zend_hash_get_current_key_ex(ah0, &index, &index_len, &num, 0, &hp0);
if (htype == HASH_KEY_IS_STRING) {
ZVAL_STRINGL(v3, index, index_len-1, 1);
} else {
if (htype == HASH_KEY_IS_LONG) {
ZVAL_LONG(v3, num);
}
}
}
PHALCON_INIT_VAR(v2);
ZVAL_ZVAL(v2, *hd, 1, 0);
PHALCON_INIT_VAR(r0);
phalcon_array_fetch(&r0, v1, v3, PHALCON_NOISY_FETCH TSRMLS_CC);
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 100);
PHALCON_INIT_VAR(r1);
phalcon_add_function(r1, r0, t0 TSRMLS_CC);
Z_ADDREF_P(r1);
if (Z_REFCOUNT_P(v1) > 1) {
zval *new_zv;
Z_DELREF_P(v1);
ALLOC_ZVAL(new_zv);
INIT_PZVAL_COPY(new_zv, v1);
v1 = new_zv;
zval_copy_ctor(new_zv);
}
phalcon_array_update(v1, v3, r1 TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_2ebb_0;
fee_2ebb_0:
zend_hash_destroy(ah0);
efree(ah0);
}
PHALCON_CALL_FUNC_PARAMS_1_NORETURN("print_r", v1, 0x015);
PHALCON_MM_RESTORE();
RETURN_NULL();
}
/**
* Builds a SELECT statement
*
* @param array $definition
* @return string
*/
PHP_METHOD(Phalcon_Db_Dialect_Oracle, select){
zval *definition, *escape_char = NULL, *columns, *selected_columns, *distinct;
zval *column = NULL, *column_item = NULL, *column_sql = NULL, *columns_sql = NULL;
zval *column_domain = NULL, *column_domain_sql = NULL, *column_alias = NULL;
zval *column_alias_sql = NULL, *tables, *selected_tables;
zval *table = NULL, *sql_table = NULL, *tables_sql = NULL, *sql, *joins;
zval *join = NULL, *type = NULL, *sql_join = NULL, *join_conditions_array = NULL;
zval *join_expressions = NULL, *join_condition = NULL, *join_expression = NULL;
zval *join_conditions = NULL, *where_conditions;
zval *where_expression = NULL, *group_items, *group_fields;
zval *group_field = NULL, *group_expression = NULL, *group_sql;
zval *group_clause, *having_conditions, *having_expression = NULL;
zval *order_fields, *order_items, *order_item = NULL;
zval *order_expression = NULL, *order_sql_item = NULL, *sql_order_type = NULL;
zval *order_sql_item_type = NULL, *order_sql, *limit_value;
zval *number, *offset, *tmp1 = NULL, *tmp2 = NULL;
zval *z_one, *ini_range, *end_range = NULL, *sql_limit;
HashTable *ah0, *ah1, *ah2, *ah3, *ah4, *ah5;
HashPosition hp0, hp1, hp2, hp3, hp4, hp5;
zval **hd;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &definition) == FAILURE) {
RETURN_NULL();
}
if (Z_TYPE_P(definition) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_db_exception_ce, "Invalid SELECT definition");
return;
}
if (!phalcon_array_isset_string(definition, SS("tables"))) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_db_exception_ce, "The index 'tables' is required in the definition array");
return;
}
if (!phalcon_array_isset_string(definition, SS("columns"))) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_db_exception_ce, "The index 'columns' is required in the definition array");
return;
}
PHALCON_MM_GROW();
if (PHALCON_GLOBAL(db).escape_identifiers) {
PHALCON_OBS_VAR(escape_char);
phalcon_read_property_this(&escape_char, this_ptr, SL("_escapeChar"), PH_NOISY TSRMLS_CC);
} else {
PHALCON_INIT_NVAR(escape_char);
}
PHALCON_OBS_VAR(columns);
phalcon_array_fetch_string(&columns, definition, SL("columns"), PH_NOISY);
if (Z_TYPE_P(columns) == IS_ARRAY) {
PHALCON_INIT_VAR(selected_columns);
array_init(selected_columns);
phalcon_is_iterable(columns, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(column);
/**
* Escape column name
*/
PHALCON_OBS_NVAR(column_item);
phalcon_array_fetch_long(&column_item, column, 0, PH_NOISY);
if (Z_TYPE_P(column_item) == IS_ARRAY) {
PHALCON_CALL_METHOD(&column_sql, this_ptr, "getsqlexpression", column_item, escape_char);
} else if (PHALCON_IS_STRING(column_item, "*")) {
PHALCON_CPY_WRT(column_sql, column_item);
} else if (PHALCON_GLOBAL(db).escape_identifiers) {
PHALCON_INIT_NVAR(column_sql);
PHALCON_CONCAT_VVV(column_sql, escape_char, column_item, escape_char);
} else {
PHALCON_CPY_WRT(columns_sql, column_item);
}
/**
* Escape column domain
*/
if (phalcon_array_isset_long(column, 1)) {
PHALCON_OBS_NVAR(column_domain);
phalcon_array_fetch_long(&column_domain, column, 1, PH_NOISY);
if (zend_is_true(column_domain)) {
if (PHALCON_GLOBAL(db).escape_identifiers) {
PHALCON_INIT_NVAR(column_domain_sql);
PHALCON_CONCAT_VVVSV(column_domain_sql, escape_char, column_domain, escape_char, ".", column_sql);
} else {
PHALCON_INIT_NVAR(column_domain_sql);
PHALCON_CONCAT_VSV(column_domain_sql, column_domain, ".", column_sql);
}
} else {
PHALCON_CPY_WRT(column_domain_sql, column_sql);
}
} else {
PHALCON_CPY_WRT(column_domain_sql, column_sql);
}
/**
* Escape column alias
*/
if (phalcon_array_isset_long(column, 2)) {
PHALCON_OBS_NVAR(column_alias);
phalcon_array_fetch_long(&column_alias, column, 2, PH_NOISY);
if (zend_is_true(column_alias)) {
if (PHALCON_GLOBAL(db).escape_identifiers) {
PHALCON_INIT_NVAR(column_alias_sql);
PHALCON_CONCAT_VSVVV(column_alias_sql, column_domain_sql, " ", escape_char, column_alias, escape_char);
} else {
PHALCON_INIT_NVAR(column_alias_sql);
PHALCON_CONCAT_VSV(column_alias_sql, column_domain_sql, " ", column_alias);
}
} else {
PHALCON_CPY_WRT(column_alias_sql, column_domain_sql);
}
} else {
PHALCON_CPY_WRT(column_alias_sql, column_domain_sql);
}
phalcon_array_append(&selected_columns, column_alias_sql, PH_SEPARATE);
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_VAR(columns_sql);
phalcon_fast_join_str(columns_sql, SL(", "), selected_columns TSRMLS_CC);
} else {
PHALCON_CPY_WRT(columns_sql, columns);
}
/**
* Check and escape tables
*/
PHALCON_OBS_VAR(tables);
phalcon_array_fetch_string(&tables, definition, SL("tables"), PH_NOISY);
if (Z_TYPE_P(tables) == IS_ARRAY) {
PHALCON_INIT_VAR(selected_tables);
array_init(selected_tables);
phalcon_is_iterable(tables, &ah1, &hp1, 0, 0);
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_HVALUE(table);
PHALCON_CALL_METHOD(&sql_table, this_ptr, "getsqltable", table, escape_char);
phalcon_array_append(&selected_tables, sql_table, PH_SEPARATE);
zend_hash_move_forward_ex(ah1, &hp1);
}
PHALCON_INIT_VAR(tables_sql);
phalcon_fast_join_str(tables_sql, SL(", "), selected_tables TSRMLS_CC);
} else {
PHALCON_CPY_WRT(tables_sql, tables);
}
PHALCON_INIT_VAR(sql);
if (phalcon_array_isset_string_fetch(&distinct, definition, SS("definition"))) {
assert(Z_TYPE_P(distinct) == IS_LONG);
if (Z_LVAL_P(distinct) == 0) {
ZVAL_STRING(sql, "SELECT ALL ", 1);
}
else if (Z_LVAL_P(distinct) == 1) {
ZVAL_STRING(sql, "SELECT DISTINCT ", 1);
}
else {
ZVAL_STRING(sql, "SELECT ", 1);
}
}
else {
ZVAL_STRING(sql, "SELECT ", 1);
}
/**
* Check for joins
*/
if (phalcon_array_isset_string(definition, SS("joins"))) {
PHALCON_OBS_VAR(joins);
phalcon_array_fetch_string(&joins, definition, SL("joins"), PH_NOISY);
phalcon_is_iterable(joins, &ah2, &hp2, 0, 0);
while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) {
PHALCON_GET_HVALUE(join);
PHALCON_OBS_NVAR(type);
phalcon_array_fetch_string(&type, join, SL("type"), PH_NOISY);
PHALCON_OBS_NVAR(table);
phalcon_array_fetch_string(&table, join, SL("source"), PH_NOISY);
PHALCON_CALL_METHOD(&sql_table, this_ptr, "getsqltable", table, escape_char);
phalcon_array_append(&selected_tables, sql_table, PH_SEPARATE);
PHALCON_INIT_NVAR(sql_join);
PHALCON_CONCAT_SVSV(sql_join, " ", type, " JOIN ", sql_table);
/**
* Check if the join has conditions
*/
if (phalcon_array_isset_string(join, SS("conditions"))) {
PHALCON_OBS_NVAR(join_conditions_array);
phalcon_array_fetch_string(&join_conditions_array, join, SL("conditions"), PH_NOISY);
if (phalcon_fast_count_ev(join_conditions_array TSRMLS_CC)) {
PHALCON_INIT_NVAR(join_expressions);
array_init(join_expressions);
phalcon_is_iterable(join_conditions_array, &ah3, &hp3, 0, 0);
while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) {
PHALCON_GET_HVALUE(join_condition);
PHALCON_CALL_METHOD(&join_expression, this_ptr, "getsqlexpression", join_condition, escape_char);
phalcon_array_append(&join_expressions, join_expression, PH_SEPARATE);
zend_hash_move_forward_ex(ah3, &hp3);
}
PHALCON_INIT_NVAR(join_conditions);
phalcon_fast_join_str(join_conditions, SL(" AND "), join_expressions TSRMLS_CC);
PHALCON_SCONCAT_SV(sql_join, " ON ", join_conditions);
}
}
phalcon_concat_self(&sql, sql_join TSRMLS_CC);
zend_hash_move_forward_ex(ah2, &hp2);
}
}
/**
* Check for a WHERE clause
*/
if (phalcon_array_isset_string(definition, SS("where"))) {
PHALCON_OBS_VAR(where_conditions);
phalcon_array_fetch_string(&where_conditions, definition, SL("where"), PH_NOISY);
if (Z_TYPE_P(where_conditions) == IS_ARRAY) {
PHALCON_CALL_METHOD(&where_expression, this_ptr, "getsqlexpression", where_conditions, escape_char);
PHALCON_SCONCAT_SV(sql, " WHERE ", where_expression);
} else {
PHALCON_SCONCAT_SV(sql, " WHERE ", where_conditions);
}
}
/**
* Check for a GROUP clause
*/
if (phalcon_array_isset_string(definition, SS("group"))) {
PHALCON_INIT_VAR(group_items);
array_init(group_items);
PHALCON_OBS_VAR(group_fields);
phalcon_array_fetch_string(&group_fields, definition, SL("group"), PH_NOISY);
phalcon_is_iterable(group_fields, &ah4, &hp4, 0, 0);
while (zend_hash_get_current_data_ex(ah4, (void**) &hd, &hp4) == SUCCESS) {
PHALCON_GET_HVALUE(group_field);
PHALCON_CALL_METHOD(&group_expression, this_ptr, "getsqlexpression", group_field, escape_char);
phalcon_array_append(&group_items, group_expression, PH_SEPARATE);
zend_hash_move_forward_ex(ah4, &hp4);
}
PHALCON_INIT_VAR(group_sql);
phalcon_fast_join_str(group_sql, SL(", "), group_items TSRMLS_CC);
PHALCON_INIT_VAR(group_clause);
PHALCON_CONCAT_SV(group_clause, " GROUP BY ", group_sql);
phalcon_concat_self(&sql, group_clause TSRMLS_CC);
}
/**
* Check for a HAVING clause
*/
if (phalcon_array_isset_string(definition, SS("having"))) {
PHALCON_OBS_VAR(having_conditions);
phalcon_array_fetch_string(&having_conditions, definition, SL("having"), PH_NOISY);
PHALCON_CALL_METHOD(&having_expression, this_ptr, "getsqlexpression", having_conditions, escape_char);
PHALCON_SCONCAT_SV(sql, " HAVING ", having_expression);
}
/**
* Check for a ORDER clause
*/
if (phalcon_array_isset_string(definition, SS("order"))) {
PHALCON_OBS_VAR(order_fields);
phalcon_array_fetch_string(&order_fields, definition, SL("order"), PH_NOISY);
PHALCON_INIT_VAR(order_items);
array_init(order_items);
phalcon_is_iterable(order_fields, &ah5, &hp5, 0, 0);
while (zend_hash_get_current_data_ex(ah5, (void**) &hd, &hp5) == SUCCESS) {
PHALCON_GET_HVALUE(order_item);
PHALCON_OBS_NVAR(order_expression);
phalcon_array_fetch_long(&order_expression, order_item, 0, PH_NOISY);
PHALCON_CALL_METHOD(&order_sql_item, this_ptr, "getsqlexpression", order_expression, escape_char);
/**
* In the numeric 1 position could be a ASC/DESC clause
*/
if (phalcon_array_isset_long(order_item, 1)) {
PHALCON_OBS_NVAR(sql_order_type);
phalcon_array_fetch_long(&sql_order_type, order_item, 1, PH_NOISY);
PHALCON_INIT_NVAR(order_sql_item_type);
PHALCON_CONCAT_VSV(order_sql_item_type, order_sql_item, " ", sql_order_type);
} else {
PHALCON_CPY_WRT(order_sql_item_type, order_sql_item);
}
phalcon_array_append(&order_items, order_sql_item_type, PH_SEPARATE);
zend_hash_move_forward_ex(ah5, &hp5);
}
PHALCON_INIT_VAR(order_sql);
phalcon_fast_join_str(order_sql, SL(", "), order_items TSRMLS_CC);
PHALCON_SCONCAT_SV(sql, " ORDER BY ", order_sql);
}
/**
* Oracle does not implement the LIMIT clause as some RDBMS do.
* We have to simulate it with subqueries and ROWNUM.
* Unfortunately because we use the column wildcard "*",
* this puts an extra column into the query result set.
*/
if (phalcon_array_isset_string_fetch(&limit_value, definition, SS("limit"))) {
if (likely(Z_TYPE_P(limit_value) == IS_ARRAY)) {
if (likely(phalcon_array_isset_string_fetch(&number, limit_value, SS("number")))) {
PHALCON_OBS_NVAR(tmp1);
phalcon_array_fetch_string(&tmp1, number, SL("value"), PH_NOISY);
if (phalcon_array_isset_string_fetch(&offset, limit_value, SS("offset"))) {
PHALCON_OBS_NVAR(tmp2);
phalcon_array_fetch_string(&tmp2, offset, SL("value"), PH_NOISY);
} else {
PHALCON_INIT_NVAR(tmp2);
ZVAL_LONG(tmp2, 0);
}
z_one = PHALCON_GLOBAL(z_one);
PHALCON_INIT_VAR(ini_range);
phalcon_add_function(ini_range, tmp2, z_one TSRMLS_CC);
PHALCON_INIT_VAR(end_range);
phalcon_add_function(end_range, tmp2, tmp1 TSRMLS_CC);
PHALCON_INIT_VAR(sql_limit);
PHALCON_SCONCAT_SVSVSV(sql_limit,"SELECT Z2.* FROM (SELECT Z1.*, ROWNUM DB_ROWNUM FROM ( ", sql, " ) Z1 ) Z2 WHERE Z2.DB_ROWNUM BETWEEN ", ini_range , " AND ", end_range );
PHALCON_CPY_WRT(sql, sql_limit);
}
} else {
PHALCON_INIT_VAR(ini_range);
ZVAL_LONG(ini_range, 1);
PHALCON_CPY_WRT(end_range, limit_value);
PHALCON_INIT_VAR(sql_limit);
PHALCON_SCONCAT_SVSVSV(sql_limit,"SELECT Z2.* FROM (SELECT Z1.*, ROWNUM DB_ROWNUM FROM ( ", sql, " ) Z1 ) Z2 WHERE Z2.DB_ROWNUM BETWEEN ", ini_range , " AND ", end_range );
PHALCON_CPY_WRT(sql, sql_limit);
}
}
RETURN_CTOR(sql);
}
/**
* Shows a backtrace item
*
* @param int $n
* @param array $trace
*/
PHP_METHOD(Phalcon_Debug, showTraceItem){
zval *n, *trace, *link_format, *space, *two_spaces, *underscore;
zval *minus, *html, *class_name;
zval *namespace_separator, *prepare_uri_class;
zval *lower_class_name, *prepared_function_name;
zval *prepare_internal_class, *type, *function_name = NULL;
zval *trace_args, *arguments, *argument = NULL, *dumped_argument = NULL;
zval *span_argument = NULL, *joined_arguments, *z_one;
zval *file, *line, *show_files, *lines = NULL, *number_lines;
zval *show_file_fragment, *before_context, *before_line;
zval *first_line = NULL, *after_context, *after_line, *last_line = NULL;
zval *comment_pattern, *charset, *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, *formatted_file = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 3, 0, &n, &trace, &link_format);
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"))) {
zend_class_entry *class_ce;
PHALCON_OBS_VAR(class_name);
phalcon_array_fetch_string(&class_name, trace, SL("class"), PH_NOISY);
class_ce = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), ZEND_FETCH_CLASS_AUTO | ZEND_FETCH_CLASS_SILENT TSRMLS_CC);
if (!class_ce) {
/* Unable to load the class, should never happen */
}
else if (is_phalcon_class(class_ce)) {
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 if (class_ce->type == ZEND_INTERNAL_CLASS) {
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 {
zend_function *func;
PHALCON_OBS_NVAR(function_name);
phalcon_array_fetch_string(&function_name, trace, SL("function"), PH_NOISY);
convert_to_string(function_name);
/**
* Check if the function exists
*/
if (phalcon_fetch_function(&func, Z_STRVAL_P(function_name), Z_STRLEN_P(function_name) TSRMLS_CC) == SUCCESS) {
/**
* Internal functions links to the PHP documentation
*/
if (func->type == ZEND_INTERNAL_FUNCTION) {
/**
* 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_CALL_METHOD(&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_COPY);
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"))) {
z_one = PHALCON_GLOBAL(z_one);
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);
PHALCON_CALL_METHOD(&formatted_file, getThis(), "getfilelink", file, line, link_format);
/**
* Realpath to the file and its line using a special header
*/
PHALCON_SCONCAT_SVSVS(html, "<br/><div class=\"error-file\">", formatted_file, " (", line, ")</div>");
PHALCON_OBS_VAR(show_files);
phalcon_read_property_this(&show_files, this_ptr, SL("_showFiles"), PH_NOISY TSRMLS_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_CALL_FUNCTION(&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 TSRMLS_CC);
/**
* File fragments just show a piece of the file where the exception is located
*/
if (zend_is_true(show_file_fragment)) {
/**
* Take lines back to the current exception's line
*/
before_context = phalcon_fetch_nproperty_this(getThis(), SL("_beforeContext"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(before_line);
phalcon_sub_function(before_line, line, before_context);
/**
* Check for overflows
*/
if (PHALCON_LT_LONG(before_line, 1)) {
PHALCON_CPY_WRT_CTOR(first_line, z_one);
} else {
PHALCON_CPY_WRT(first_line, before_line);
}
/**
* Take lines after the current exception's line
*/
after_context = phalcon_fetch_nproperty_this(getThis(), SL("_afterContext"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(after_line);
phalcon_add_function(after_line, line, after_context);
/**
* 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_CTOR(first_line, z_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);
charset = phalcon_fetch_static_property_ce(phalcon_debug_ce, SL("_charset") TSRMLS_CC);
PHALCON_INIT_VAR(tab);
ZVAL_STRING(tab, "\t", 1);
PHALCON_INIT_VAR(comment);
ZVAL_STRING(comment, "* /", 1);
PHALCON_CPY_WRT(i, first_line);
while (PHALCON_LE(i, last_line)) {
/**
* Current line in the file
*/
PHALCON_INIT_NVAR(line_position);
phalcon_sub_function(line_position, i, z_one);
/**
* 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, NULL, PHALCON_TRIM_RIGHT TSRMLS_CC);
PHALCON_INIT_NVAR(is_comment);
RETURN_MM_ON_FAILURE(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_htmlentities(escaped_line, spaced_current_line, NULL, charset TSRMLS_CC);
phalcon_concat_self(&html, escaped_line TSRMLS_CC);
}
}
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);
}