/**
* Lists table indexes
*
* <code>
* print_r($connection->describeIndexes('robots_parts'));
* </code>
*
* @param string table
* @param string schema
* @return \Phalcon\Db\IndexInterface[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Mysql, describeIndexes) {
HashTable *_5, *_15;
HashPosition _4, _14;
zephir_fcall_cache_entry *_20 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *table_param = NULL, *schema = NULL, *indexes = NULL, *index = NULL, *keyName = NULL, *indexObjects = NULL, *columns = NULL, *name = NULL, *_0 = NULL, *_1, *_2 = NULL, *_3, **_6, **_16, *_7$$4 = NULL, *_8$$3, *_10$$3, *_11$$3, *_9$$6, *_12$$7 = NULL, *_13$$8 = NULL, *_17$$10 = NULL, *_18$$10, *_19$$10;
zval *table = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &table_param, &schema);
if (unlikely(Z_TYPE_P(table_param) != IS_STRING && Z_TYPE_P(table_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'table' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(table_param) == IS_STRING)) {
zephir_get_strval(table, table_param);
} else {
ZEPHIR_INIT_VAR(table);
ZVAL_EMPTY_STRING(table);
}
if (!schema) {
schema = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_INIT_VAR(indexes);
array_init(indexes);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_dialect"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&_2, _1, "describeindexes", NULL, 0, table, schema);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_3);
ZVAL_LONG(_3, 2);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "fetchall", NULL, 0, _2, _3);
zephir_check_call_status();
zephir_is_iterable(_0, &_5, &_4, 0, 0, "phalcon/db/adapter/pdo/mysql.zep", 389);
for (
; zephir_hash_get_current_data_ex(_5, (void**) &_6, &_4) == SUCCESS
; zephir_hash_move_forward_ex(_5, &_4)
) {
ZEPHIR_GET_HVALUE(index, _6);
zephir_array_fetch_string(&keyName, index, SL("Key_name"), PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/mysql.zep", 365 TSRMLS_CC);
if (!(zephir_array_isset(indexes, keyName))) {
ZEPHIR_INIT_NVAR(_7$$4);
array_init(_7$$4);
zephir_array_update_zval(&indexes, keyName, &_7$$4, PH_COPY | PH_SEPARATE);
}
zephir_array_fetch(&_8$$3, indexes, keyName, PH_READONLY, "phalcon/db/adapter/pdo/mysql.zep", 371 TSRMLS_CC);
if (!(zephir_array_isset_string(_8$$3, SS("columns")))) {
ZEPHIR_INIT_NVAR(columns);
array_init(columns);
} else {
zephir_array_fetch(&_9$$6, indexes, keyName, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/mysql.zep", 374 TSRMLS_CC);
ZEPHIR_OBS_NVAR(columns);
zephir_array_fetch_string(&columns, _9$$6, SL("columns"), PH_NOISY, "phalcon/db/adapter/pdo/mysql.zep", 374 TSRMLS_CC);
}
zephir_array_fetch_string(&_10$$3, index, SL("Column_name"), PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/mysql.zep", 377 TSRMLS_CC);
zephir_array_append(&columns, _10$$3, PH_SEPARATE, "phalcon/db/adapter/pdo/mysql.zep", 377);
zephir_array_update_multi(&indexes, &columns TSRMLS_CC, SL("zs"), 3, keyName, SL("columns"));
zephir_array_fetch_string(&_11$$3, index, SL("Non_unique"), PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/mysql.zep", 382 TSRMLS_CC);
if (ZEPHIR_IS_STRING(keyName, "PRIMARY")) {
ZEPHIR_INIT_NVAR(_12$$7);
ZVAL_STRING(_12$$7, "PRIMARY", 1);
zephir_array_update_multi(&indexes, &_12$$7 TSRMLS_CC, SL("zs"), 3, keyName, SL("type"));
} else if (ZEPHIR_IS_LONG(_11$$3, 0)) {
ZEPHIR_INIT_NVAR(_13$$8);
ZVAL_STRING(_13$$8, "UNIQUE", 1);
zephir_array_update_multi(&indexes, &_13$$8 TSRMLS_CC, SL("zs"), 3, keyName, SL("type"));
} else {
zephir_array_update_multi(&indexes, &ZEPHIR_GLOBAL(global_null) TSRMLS_CC, SL("zs"), 3, keyName, SL("type"));
}
}
ZEPHIR_INIT_VAR(indexObjects);
array_init(indexObjects);
zephir_is_iterable(indexes, &_15, &_14, 0, 0, "phalcon/db/adapter/pdo/mysql.zep", 394);
for (
; zephir_hash_get_current_data_ex(_15, (void**) &_16, &_14) == SUCCESS
; zephir_hash_move_forward_ex(_15, &_14)
) {
ZEPHIR_GET_HMKEY(name, _15, _14);
ZEPHIR_GET_HVALUE(index, _16);
ZEPHIR_INIT_NVAR(_17$$10);
object_init_ex(_17$$10, phalcon_db_index_ce);
zephir_array_fetch_string(&_18$$10, index, SL("columns"), PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/mysql.zep", 391 TSRMLS_CC);
zephir_array_fetch_string(&_19$$10, index, SL("type"), PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/mysql.zep", 391 TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, _17$$10, "__construct", &_20, 15, name, _18$$10, _19$$10);
zephir_check_call_status();
zephir_array_update_zval(&indexObjects, name, &_17$$10, PH_COPY | PH_SEPARATE);
}
RETURN_CCTOR(indexObjects);
}
/**
* Loads registered template engines, if none is registered it will use Phalcon\Mvc\View\Engine\Php
*
* @return array
*/
PHP_METHOD(Phalcon_Mvc_View, _loadTemplateEngines){
zval *engines = NULL, *dependency_injector = NULL, *registered_engines = NULL;
zval *number_engines = NULL, *php_engine = NULL, *arguments = NULL;
zval *engine_service = NULL, *extension = NULL, *engine_object = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(engines);
phalcon_read_property(&engines, this_ptr, SL("_engines"), PH_NOISY_CC);
if (Z_TYPE_P(engines) == IS_BOOL && !Z_BVAL_P(engines)) {
PHALCON_INIT_VAR(dependency_injector);
phalcon_read_property(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
PHALCON_INIT_VAR(engines);
array_init(engines);
PHALCON_INIT_VAR(registered_engines);
phalcon_read_property(®istered_engines, this_ptr, SL("_registeredEngines"), PH_NOISY_CC);
PHALCON_INIT_VAR(number_engines);
phalcon_fast_count(number_engines, registered_engines TSRMLS_CC);
if (phalcon_compare_strict_long(number_engines, 0 TSRMLS_CC)) {
PHALCON_INIT_VAR(php_engine);
object_init_ex(php_engine, phalcon_mvc_view_engine_php_ce);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(php_engine, "__construct", this_ptr, dependency_injector, PH_CHECK);
phalcon_array_update_string(&engines, SL(".phtml"), &php_engine, PH_COPY | PH_SEPARATE TSRMLS_CC);
} else {
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_view_exception_ce, "A dependency injector container is required to obtain the application services");
return;
}
PHALCON_INIT_VAR(arguments);
array_init(arguments);
phalcon_array_append(&arguments, this_ptr, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&arguments, dependency_injector, PH_SEPARATE TSRMLS_CC);
if (!phalcon_valid_foreach(registered_engines TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(registered_engines);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_ecde_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_ecde_0;
}
PHALCON_INIT_VAR(extension);
PHALCON_GET_FOREACH_KEY(extension, ah0, hp0);
PHALCON_INIT_VAR(engine_service);
ZVAL_ZVAL(engine_service, *hd, 1, 0);
PHALCON_INIT_VAR(engine_object);
PHALCON_CALL_METHOD_PARAMS_2(engine_object, dependency_injector, "getshared", engine_service, arguments, PH_NO_CHECK);
phalcon_array_update_zval(&engines, extension, &engine_object, PH_COPY | PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_ecde_0;
fee_ecde_0:
if(0){}
}
phalcon_update_property_zval(this_ptr, SL("_engines"), engines TSRMLS_CC);
} else {
PHALCON_INIT_VAR(engines);
phalcon_read_property(&engines, this_ptr, SL("_engines"), PH_NOISY_CC);
}
RETURN_CCTOR(engines);
}
/**
* Validate a set of data according to a set of rules
*
* @param array|object data
* @param object entity
* @return Phalcon\Validation\Message\Group
*/
PHP_METHOD(Phalcon_Validation, validate) {
HashTable *_2;
HashPosition _1;
zend_bool _0;
int ZEPHIR_LAST_CALL_STATUS;
zval *data = NULL, *entity = NULL, *validators, *messages = NULL, *scope = NULL, *field = NULL, *validator = NULL, *status = NULL, **_3, *_4 = NULL, *_5 = NULL, *_6 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 2, &data, &entity);
if (!data) {
data = ZEPHIR_GLOBAL(global_null);
}
if (!entity) {
entity = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_OBS_VAR(validators);
zephir_read_property_this(&validators, this_ptr, SL("_validators"), PH_NOISY_CC);
if (Z_TYPE_P(validators) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "There are no validators to validate", "phalcon/validation.zep", 83);
return;
}
zephir_update_property_this(this_ptr, SL("_values"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC);
ZEPHIR_INIT_VAR(messages);
object_init_ex(messages, phalcon_validation_message_group_ce);
ZEPHIR_CALL_METHOD(NULL, messages, "__construct", NULL, 171);
zephir_check_call_status();
if ((zephir_method_exists_ex(this_ptr, SS("beforevalidation") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD(&status, this_ptr, "beforevalidation", NULL, 0, data, entity, messages);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(status)) {
RETURN_CCTOR(status);
}
}
zephir_update_property_this(this_ptr, SL("_messages"), messages TSRMLS_CC);
_0 = Z_TYPE_P(data) == IS_ARRAY;
if (!(_0)) {
_0 = Z_TYPE_P(data) == IS_OBJECT;
}
if (_0) {
zephir_update_property_this(this_ptr, SL("_data"), data TSRMLS_CC);
}
zephir_is_iterable(validators, &_2, &_1, 0, 0, "phalcon/validation.zep", 138);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HVALUE(scope, _3);
if (Z_TYPE_P(scope) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "The validator scope is not valid", "phalcon/validation.zep", 115);
return;
}
ZEPHIR_OBS_NVAR(field);
zephir_array_fetch_long(&field, scope, 0, PH_NOISY, "phalcon/validation.zep", 118 TSRMLS_CC);
ZEPHIR_OBS_NVAR(validator);
zephir_array_fetch_long(&validator, scope, 1, PH_NOISY, "phalcon/validation.zep", 119 TSRMLS_CC);
if (Z_TYPE_P(validator) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "One of the validators is not valid", "phalcon/validation.zep", 122);
return;
}
ZEPHIR_CALL_METHOD(&_4, validator, "validate", NULL, 0, this_ptr, field);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_4)) {
ZEPHIR_INIT_NVAR(_6);
ZVAL_STRING(_6, "cancelOnFail", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_5, validator, "getoption", NULL, 0, _6);
zephir_check_temp_parameter(_6);
zephir_check_call_status();
if (zephir_is_true(_5)) {
break;
}
}
}
ZEPHIR_OBS_NVAR(messages);
zephir_read_property_this(&messages, this_ptr, SL("_messages"), PH_NOISY_CC);
if ((zephir_method_exists_ex(this_ptr, SS("aftervalidation") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "aftervalidation", NULL, 0, data, entity, messages);
zephir_check_call_status();
}
RETURN_CCTOR(messages);
}
/**
* Returns a complete resultset as an array, if the resultset has a big number of rows
* it could consume more memory than currently it does.
*
* @return array
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, toArray){
zval *type, *result = NULL, *active_row = NULL, *records = NULL, *row_count;
PHALCON_MM_GROW();
PHALCON_OBS_VAR(type);
phalcon_read_property(&type, this_ptr, SL("_type"), PH_NOISY_CC);
if (zend_is_true(type)) {
PHALCON_OBS_VAR(result);
phalcon_read_property(&result, this_ptr, SL("_result"), PH_NOISY_CC);
if (Z_TYPE_P(result) == IS_OBJECT) {
PHALCON_OBS_VAR(active_row);
phalcon_read_property(&active_row, this_ptr, SL("_activeRow"), PH_NOISY_CC);
/**
* Check if we need to re-execute the query
*/
if (Z_TYPE_P(active_row) != IS_NULL) {
PHALCON_CALL_METHOD_NORETURN(result, "execute");
}
/**
* We fetch all the results in memory
*/
PHALCON_INIT_VAR(records);
PHALCON_CALL_METHOD(records, result, "fetchall");
} else {
PHALCON_INIT_NVAR(records);
array_init(records);
}
} else {
PHALCON_OBS_NVAR(records);
phalcon_read_property(&records, this_ptr, SL("_rows"), PH_NOISY_CC);
if (Z_TYPE_P(records) != IS_ARRAY) {
PHALCON_OBS_NVAR(result);
phalcon_read_property(&result, this_ptr, SL("_result"), PH_NOISY_CC);
if (Z_TYPE_P(result) == IS_OBJECT) {
PHALCON_OBS_NVAR(active_row);
phalcon_read_property(&active_row, this_ptr, SL("_activeRow"), PH_NOISY_CC);
/**
* Check if we need to re-execute the query
*/
if (Z_TYPE_P(active_row) != IS_NULL) {
PHALCON_CALL_METHOD_NORETURN(result, "execute");
}
/**
* We fetch all the results in memory again
*/
PHALCON_INIT_NVAR(records);
PHALCON_CALL_METHOD(records, result, "fetchall");
phalcon_update_property_zval(this_ptr, SL("_rows"), records TSRMLS_CC);
/**
* Update the row count
*/
PHALCON_INIT_VAR(row_count);
phalcon_fast_count(row_count, records TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_count"), row_count TSRMLS_CC);
}
}
}
RETURN_CCTOR(records);
}
/**
* Returns the string meaning of a logger constant
*
* @param integer $type
* @return string
*/
PHP_METHOD(Phalcon_Logger_Adapter_File, getTypeString){
zval *type = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL, *r9 = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL, *t6 = NULL;
zval *t7 = NULL, *t8 = NULL, *t9 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &type) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_SEPARATE_PARAM(type);
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 7);
PHALCON_ALLOC_ZVAL_MM(r0);
is_equal_function(r0, type, t0 TSRMLS_CC);
if (zend_is_true(r0)) {
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "DEBUG", 1);
goto se_654f_0;
}
PHALCON_INIT_VAR(t1);
ZVAL_LONG(t1, 3);
PHALCON_ALLOC_ZVAL_MM(r1);
is_equal_function(r1, type, t1 TSRMLS_CC);
if (zend_is_true(r1)) {
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "ERROR", 1);
goto se_654f_0;
}
PHALCON_INIT_VAR(t2);
ZVAL_LONG(t2, 4);
PHALCON_ALLOC_ZVAL_MM(r2);
is_equal_function(r2, type, t2 TSRMLS_CC);
if (zend_is_true(r2)) {
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "WARNING", 1);
goto se_654f_0;
}
PHALCON_INIT_VAR(t3);
ZVAL_LONG(t3, 1);
PHALCON_ALLOC_ZVAL_MM(r3);
is_equal_function(r3, type, t3 TSRMLS_CC);
if (zend_is_true(r3)) {
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "CRITICAL", 1);
goto se_654f_0;
}
PHALCON_INIT_VAR(t4);
ZVAL_LONG(t4, 8);
PHALCON_ALLOC_ZVAL_MM(r4);
is_equal_function(r4, type, t4 TSRMLS_CC);
if (zend_is_true(r4)) {
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "CUSTOM", 1);
goto se_654f_0;
}
PHALCON_INIT_VAR(t5);
ZVAL_LONG(t5, 2);
PHALCON_ALLOC_ZVAL_MM(r5);
is_equal_function(r5, type, t5 TSRMLS_CC);
if (zend_is_true(r5)) {
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "ALERT", 1);
goto se_654f_0;
}
PHALCON_INIT_VAR(t6);
ZVAL_LONG(t6, 5);
PHALCON_ALLOC_ZVAL_MM(r6);
is_equal_function(r6, type, t6 TSRMLS_CC);
if (zend_is_true(r6)) {
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "NOTICE", 1);
goto se_654f_0;
}
PHALCON_INIT_VAR(t7);
ZVAL_LONG(t7, 6);
PHALCON_ALLOC_ZVAL_MM(r7);
is_equal_function(r7, type, t7 TSRMLS_CC);
if (zend_is_true(r7)) {
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "INFO", 1);
goto se_654f_0;
}
PHALCON_INIT_VAR(t8);
ZVAL_LONG(t8, 0);
PHALCON_ALLOC_ZVAL_MM(r8);
is_equal_function(r8, type, t8 TSRMLS_CC);
if (zend_is_true(r8)) {
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "EMERGENCE", 1);
goto se_654f_0;
}
PHALCON_INIT_VAR(t9);
ZVAL_LONG(t9, 9);
PHALCON_ALLOC_ZVAL_MM(r9);
is_equal_function(r9, type, t9 TSRMLS_CC);
if (zend_is_true(r9)) {
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "SPECIAL", 1);
goto se_654f_0;
}
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "CUSTOM", 1);
se_654f_0:
RETURN_CCTOR(type);
}
/**
* Produces an string representation of a variable
*
* @param mixed $variable
* @return string
*/
PHP_METHOD(Phalcon_Debug, _getVarDump){
zval *variable, *class_name, *dumped_object;
zval *array_dump = NULL, *dump = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &variable);
if (PHALCON_IS_SCALAR(variable)) {
/**
* Boolean variables are represented as 'true'/'false'
*/
if (Z_TYPE_P(variable) == IS_BOOL) {
if (zend_is_true(variable)) {
RETURN_MM_STRING("true", 1);
} else {
RETURN_MM_STRING("false", 1);
}
}
/**
* String variables are escaped to avoid XSS injections
*/
if (Z_TYPE_P(variable) == IS_STRING) {
phalcon_call_method_p1(return_value, this_ptr, "_escapestring", variable);
RETURN_MM();
}
/**
* Other scalar variables are just converted to strings
*/
RETURN_CCTOR(variable);
}
/**
* If the variable is an object print its class name
*/
if (Z_TYPE_P(variable) == IS_OBJECT) {
PHALCON_INIT_VAR(class_name);
phalcon_get_class(class_name, variable, 0 TSRMLS_CC);
/**
* Try to check for a 'dump' method, this surely produces a better printable
* representation
*/
if (phalcon_method_exists_ex(variable, SS("dump") TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_VAR(dumped_object);
phalcon_call_method(dumped_object, variable, "dump");
/**
* dump() must return an array, generate a recursive representation using
* getArrayDump
*/
PHALCON_INIT_VAR(array_dump);
phalcon_call_method_p1(array_dump, this_ptr, "_getarraydump", dumped_object);
PHALCON_INIT_VAR(dump);
PHALCON_CONCAT_SVSVS(dump, "Object(", class_name, ": ", array_dump, ")");
} else {
/**
* If dump() is not available just print the class name
*/
PHALCON_INIT_NVAR(dump);
PHALCON_CONCAT_SVS(dump, "Object(", class_name, ")</span>");
}
RETURN_CTOR(dump);
}
/**
* Recursively process the array and enclose it in Array()
*/
if (Z_TYPE_P(variable) == IS_ARRAY) {
PHALCON_INIT_NVAR(array_dump);
phalcon_call_method_p1(array_dump, this_ptr, "_getarraydump", variable);
PHALCON_CONCAT_SVS(return_value, "Array(", array_dump, ")");
RETURN_MM();
}
/**
* Null variables are represented as 'null'
* Other types are represented by its type
*/
RETURN_MM_STRING(zend_zval_type_name(variable), 1);
}
/**
* Renders a view
*
* @param string path
* @param array params
* @return string
*/
PHP_METHOD(Phalcon_Mvc_View_Simple, render) {
zephir_nts_static zephir_fcall_cache_entry *_2 = NULL, *_3 = NULL, *_5 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *path_param = NULL, *params = NULL, *cache = NULL, *key = NULL, *lifetime = NULL, *cacheOptions, *content = NULL, *viewParams, *mergedParams = NULL, *_0 = NULL, *_1, *_4 = NULL;
zval *path = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &path_param, ¶ms);
if (unlikely(Z_TYPE_P(path_param) != IS_STRING && Z_TYPE_P(path_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'path' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(path_param) == IS_STRING)) {
zephir_get_strval(path, path_param);
} else {
ZEPHIR_INIT_VAR(path);
ZVAL_EMPTY_STRING(path);
}
if (!params) {
params = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_CALL_METHOD(&cache, this_ptr, "getcache", NULL);
zephir_check_call_status();
if (Z_TYPE_P(cache) == IS_OBJECT) {
ZEPHIR_CALL_METHOD(&_0, cache, "isstarted", NULL);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_0)) {
ZEPHIR_INIT_VAR(key);
ZVAL_NULL(key);
ZEPHIR_INIT_VAR(lifetime);
ZVAL_NULL(lifetime);
ZEPHIR_OBS_VAR(cacheOptions);
zephir_read_property_this(&cacheOptions, this_ptr, SL("_cacheOptions"), PH_NOISY_CC);
if (Z_TYPE_P(cacheOptions) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(key);
zephir_array_isset_string_fetch(&key, cacheOptions, SS("key"), 0 TSRMLS_CC);
ZEPHIR_OBS_NVAR(lifetime);
zephir_array_isset_string_fetch(&lifetime, cacheOptions, SS("lifetime"), 0 TSRMLS_CC);
}
if (Z_TYPE_P(key) == IS_NULL) {
ZEPHIR_INIT_NVAR(key);
zephir_md5(key, path);
}
ZEPHIR_CALL_METHOD(&content, cache, "start", NULL, key, lifetime);
zephir_check_call_status();
if (Z_TYPE_P(content) != IS_NULL) {
zephir_update_property_this(this_ptr, SL("_content"), content TSRMLS_CC);
RETURN_CCTOR(content);
}
}
}
ZEPHIR_INIT_VAR(_1);
zephir_create_symbol_table(TSRMLS_C);
ZEPHIR_CALL_FUNCTION(NULL, "ob_start", &_2);
zephir_check_call_status();
ZEPHIR_OBS_VAR(viewParams);
zephir_read_property_this(&viewParams, this_ptr, SL("_viewParams"), PH_NOISY_CC);
if (Z_TYPE_P(params) == IS_ARRAY) {
if (Z_TYPE_P(viewParams) == IS_ARRAY) {
ZEPHIR_INIT_VAR(mergedParams);
zephir_fast_array_merge(mergedParams, &(viewParams), &(params) TSRMLS_CC);
} else {
ZEPHIR_CPY_WRT(mergedParams, params);
}
} else {
ZEPHIR_CPY_WRT(mergedParams, viewParams);
}
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_internalrender", &_3, path, mergedParams);
zephir_check_call_status();
if (Z_TYPE_P(cache) == IS_OBJECT) {
ZEPHIR_CALL_METHOD(&_0, cache, "isstarted", NULL);
zephir_check_call_status();
if (ZEPHIR_IS_TRUE_IDENTICAL(_0)) {
ZEPHIR_CALL_METHOD(&_4, cache, "isfresh", NULL);
zephir_check_call_status();
if (ZEPHIR_IS_TRUE_IDENTICAL(_4)) {
ZEPHIR_CALL_METHOD(NULL, cache, "save", NULL);
zephir_check_call_status();
} else {
ZEPHIR_CALL_METHOD(NULL, cache, "stop", NULL);
zephir_check_call_status();
}
} else {
ZEPHIR_CALL_METHOD(NULL, cache, "stop", NULL);
zephir_check_call_status();
}
}
ZEPHIR_CALL_FUNCTION(NULL, "ob_end_clean", &_5);
zephir_check_call_status();
RETURN_MM_MEMBER(this_ptr, "_content");
}
/**
* Returns routePaths
*/
PHP_METHOD(Phalcon_Mvc_Router_Route, getRoutePaths) {
int _0;
zval *paths = NULL, *moduleName = NULL, *controllerName = NULL, *actionName = NULL, *parts, *routePaths = NULL, *realClassName = NULL, *namespaceName, *_1;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &paths);
if (!paths) {
paths = ZEPHIR_GLOBAL(global_null);
}
if (Z_TYPE_P(paths) != IS_NULL) {
if (Z_TYPE_P(paths) == IS_STRING) {
ZEPHIR_INIT_VAR(moduleName);
ZVAL_NULL(moduleName);
ZEPHIR_INIT_VAR(controllerName);
ZVAL_NULL(controllerName);
ZEPHIR_INIT_VAR(actionName);
ZVAL_NULL(actionName);
ZEPHIR_INIT_VAR(parts);
zephir_fast_explode_str(parts, SL("::"), paths, LONG_MAX TSRMLS_CC);
do {
_0 = zephir_fast_count_int(parts TSRMLS_CC);
if (_0 == 3) {
ZEPHIR_OBS_NVAR(moduleName);
zephir_array_fetch_long(&moduleName, parts, 0, PH_NOISY, "phalcon/mvc/router/route.zep", 353 TSRMLS_CC);
ZEPHIR_OBS_NVAR(controllerName);
zephir_array_fetch_long(&controllerName, parts, 1, PH_NOISY, "phalcon/mvc/router/route.zep", 354 TSRMLS_CC);
ZEPHIR_OBS_NVAR(actionName);
zephir_array_fetch_long(&actionName, parts, 2, PH_NOISY, "phalcon/mvc/router/route.zep", 355 TSRMLS_CC);
break;
}
if (_0 == 2) {
ZEPHIR_OBS_NVAR(controllerName);
zephir_array_fetch_long(&controllerName, parts, 0, PH_NOISY, "phalcon/mvc/router/route.zep", 359 TSRMLS_CC);
ZEPHIR_OBS_NVAR(actionName);
zephir_array_fetch_long(&actionName, parts, 1, PH_NOISY, "phalcon/mvc/router/route.zep", 360 TSRMLS_CC);
break;
}
if (_0 == 1) {
ZEPHIR_OBS_NVAR(controllerName);
zephir_array_fetch_long(&controllerName, parts, 0, PH_NOISY, "phalcon/mvc/router/route.zep", 364 TSRMLS_CC);
break;
}
} while(0);
ZEPHIR_INIT_VAR(routePaths);
array_init(routePaths);
if (Z_TYPE_P(moduleName) != IS_NULL) {
zephir_array_update_string(&routePaths, SL("module"), &moduleName, PH_COPY | PH_SEPARATE);
}
if (Z_TYPE_P(controllerName) != IS_NULL) {
if (zephir_memnstr_str(controllerName, SL("\\"), "phalcon/mvc/router/route.zep", 379)) {
ZEPHIR_INIT_VAR(realClassName);
zephir_get_class_ns(realClassName, controllerName, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(namespaceName);
zephir_get_ns_class(namespaceName, controllerName, 0 TSRMLS_CC);
if (zephir_is_true(namespaceName)) {
zephir_array_update_string(&routePaths, SL("namespace"), &namespaceName, PH_COPY | PH_SEPARATE);
}
} else {
ZEPHIR_CPY_WRT(realClassName, controllerName);
}
ZEPHIR_INIT_VAR(_1);
zephir_uncamelize(_1, realClassName);
zephir_array_update_string(&routePaths, SL("controller"), &_1, PH_COPY | PH_SEPARATE);
}
if (Z_TYPE_P(actionName) != IS_NULL) {
zephir_array_update_string(&routePaths, SL("action"), &actionName, PH_COPY | PH_SEPARATE);
}
} else {
ZEPHIR_CPY_WRT(routePaths, paths);
}
} else {
ZEPHIR_INIT_NVAR(routePaths);
array_init(routePaths);
}
if (Z_TYPE_P(routePaths) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_router_exception_ce, "The route contains invalid paths", "phalcon/mvc/router/route.zep", 411);
return;
}
RETURN_CCTOR(routePaths);
}
/**
* @todo this method can be write differently with (P< style match
* Matches a user submitted path with parts defined by a map. Assigns and
* returns an array of variables on a successful match.
*
* @param string $path Path used to match against this routing map
* @return array|false An array of assigned values or a false on a mismatch
*/
PHP_METHOD(Yaf_Route_Rewrite, _match) {
zephir_nts_static zephir_fcall_cache_entry *_27 = NULL, *_33 = NULL;
zend_bool _12, _28, _32;
HashTable *_7, *_22, *_35;
HashPosition _6, _21, _34;
int staticCount, pathStaticCount, ZEPHIR_LAST_CALL_STATUS;
zval *path_param = NULL, *values, *matchedPath = NULL, *parts, *variables, *wildcardData, *name = NULL, *part = NULL, *pos = NULL, *pathMatch, *count = NULL, *i = NULL, *varr = NULL, *pathPart = NULL, *tmpReturn = NULL, *_0, *_1 = NULL, *_2 = NULL, *_3, _4 = zval_used_for_init, _5 = zval_used_for_init, **_8, _9 = zval_used_for_init, _10 = zval_used_for_init, *_11 = NULL, _13 = zval_used_for_init, _14 = zval_used_for_init, *_15 = NULL, _16 = zval_used_for_init, _17 = zval_used_for_init, *_18 = NULL, _19 = zval_used_for_init, *_20 = NULL, **_23, *_24 = NULL, *_25, *_26, *_29 = NULL, *_30, *_31 = NULL, **_36;
zval *path = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &path_param);
zephir_get_strval(path, path_param);
staticCount = 0;
pathStaticCount = 0;
ZEPHIR_INIT_VAR(values);
array_init(values);
ZEPHIR_INIT_VAR(matchedPath);
ZVAL_STRING(matchedPath, "", 1);
ZEPHIR_INIT_VAR(parts);
array_init(parts);
ZEPHIR_INIT_VAR(variables);
array_init(variables);
ZEPHIR_INIT_VAR(wildcardData);
array_init(wildcardData);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_route"), PH_NOISY_CC);
if (!ZEPHIR_IS_STRING_IDENTICAL(_0, "")) {
ZEPHIR_INIT_VAR(_1);
ZEPHIR_INIT_VAR(_2);
_3 = zephir_fetch_nproperty_this(this_ptr, SL("_route"), PH_NOISY_CC);
ZEPHIR_SINIT_VAR(_4);
ZVAL_STRING(&_4, "/", 0);
zephir_fast_trim(_2, _3, &_4, ZEPHIR_TRIM_BOTH TSRMLS_CC);
ZEPHIR_SINIT_VAR(_5);
ZVAL_STRING(&_5, "/", 0);
zephir_fast_explode(_1, &_5, _2, LONG_MAX TSRMLS_CC);
zephir_is_iterable(_1, &_7, &_6, 0, 0, "yaf/Route/rewrite.zep", 135);
for (
; zephir_hash_get_current_data_ex(_7, (void**) &_8, &_6) == SUCCESS
; zephir_hash_move_forward_ex(_7, &_6)
) {
ZEPHIR_GET_HMKEY(pos, _7, _6);
ZEPHIR_GET_HVALUE(part, _8);
ZEPHIR_SINIT_NVAR(_9);
ZVAL_LONG(&_9, 0);
ZEPHIR_SINIT_NVAR(_10);
ZVAL_LONG(&_10, 1);
ZEPHIR_INIT_NVAR(_11);
zephir_substr(_11, part, 0 , 1 , 0);
_12 = ZEPHIR_IS_STRING(_11, ":");
if (_12) {
ZEPHIR_SINIT_NVAR(_13);
ZVAL_LONG(&_13, 1);
ZEPHIR_SINIT_NVAR(_14);
ZVAL_LONG(&_14, 1);
ZEPHIR_INIT_NVAR(_15);
zephir_substr(_15, part, 1 , 1 , 0);
_12 = !ZEPHIR_IS_STRING(_15, ":");
}
if (_12) {
ZEPHIR_SINIT_NVAR(_16);
ZVAL_LONG(&_16, 1);
ZEPHIR_INIT_NVAR(name);
zephir_substr(name, part, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH);
zephir_array_update_zval(&parts, pos, &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
zephir_array_update_zval(&variables, pos, &name, PH_COPY | PH_SEPARATE);
} else {
ZEPHIR_SINIT_NVAR(_16);
ZVAL_LONG(&_16, 0);
ZEPHIR_SINIT_NVAR(_17);
ZVAL_LONG(&_17, 1);
ZEPHIR_INIT_NVAR(_18);
zephir_substr(_18, part, 0 , 1 , 0);
if (ZEPHIR_IS_STRING(_18, ":")) {
ZEPHIR_SINIT_NVAR(_19);
ZVAL_LONG(&_19, 1);
ZEPHIR_INIT_NVAR(_20);
zephir_substr(_20, part, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH);
ZEPHIR_CPY_WRT(part, _20);
}
zephir_array_update_zval(&parts, pos, &part, PH_COPY | PH_SEPARATE);
if (!ZEPHIR_IS_STRING_IDENTICAL(part, "*")) {
staticCount++;
}
}
}
}
if (!ZEPHIR_IS_STRING_IDENTICAL(path, "")) {
ZEPHIR_INIT_VAR(pathMatch);
ZEPHIR_SINIT_NVAR(_4);
ZVAL_STRING(&_4, "/", 0);
zephir_fast_explode(pathMatch, &_4, path, LONG_MAX TSRMLS_CC);
zephir_is_iterable(pathMatch, &_22, &_21, 0, 0, "yaf/Route/rewrite.zep", 193);
for (
; zephir_hash_get_current_data_ex(_22, (void**) &_23, &_21) == SUCCESS
; zephir_hash_move_forward_ex(_22, &_21)
) {
ZEPHIR_GET_HMKEY(pos, _22, _21);
ZEPHIR_GET_HVALUE(pathPart, _23);
if (!(zephir_array_key_exists(parts, pos TSRMLS_CC))) {
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_LNVAR(_24);
ZEPHIR_CONCAT_VS(_24, pathPart, "/");
zephir_concat_self(&matchedPath, _24 TSRMLS_CC);
zephir_array_fetch(&_25, parts, pos, PH_NOISY | PH_READONLY, "yaf/Route/rewrite.zep", 150 TSRMLS_CC);
if (ZEPHIR_IS_STRING(_25, "*")) {
ZEPHIR_INIT_NVAR(count);
ZVAL_LONG(count, zephir_fast_count_int(pathMatch TSRMLS_CC));
ZEPHIR_CPY_WRT(i, pos);
while (1) {
if (!(ZEPHIR_LT(i, count))) {
break;
}
zephir_array_fetch(&_26, pathMatch, i, PH_NOISY | PH_READONLY, "yaf/Route/rewrite.zep", 154 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&varr, "urldecode", &_27, _26);
zephir_check_call_status();
_12 = !(zephir_array_isset(wildcardData, varr));
if (_12) {
_3 = zephir_fetch_nproperty_this(this_ptr, SL("_default"), PH_NOISY_CC);
_12 = !(zephir_array_isset(_3, varr));
}
_28 = _12;
if (_28) {
_28 = !(zephir_array_isset(values, varr));
}
if (_28) {
ZEPHIR_INIT_LNVAR(_29);
if (zephir_array_isset_long(pathMatch, (zephir_get_numberval(i) + 1))) {
zephir_array_fetch_long(&_30, pathMatch, (zephir_get_numberval(i) + 1), PH_NOISY | PH_READONLY, "yaf/Route/rewrite.zep", 157 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_29, "urldecode", &_27, _30);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(_29);
ZVAL_NULL(_29);
}
zephir_array_update_zval(&wildcardData, varr, &_29, PH_COPY | PH_SEPARATE);
}
ZEPHIR_INIT_NVAR(_1);
ZVAL_LONG(_1, 2);
ZEPHIR_ADD_ASSIGN(i, _1);
}
ZEPHIR_INIT_NVAR(matchedPath);
ZEPHIR_SINIT_NVAR(_5);
ZVAL_STRING(&_5, "/", 0);
zephir_fast_join(matchedPath, &_5, pathMatch TSRMLS_CC);
break;
}
if (zephir_array_isset(variables, pos)) {
ZEPHIR_OBS_NVAR(name);
zephir_array_fetch(&name, variables, pos, PH_NOISY, "yaf/Route/rewrite.zep", 165 TSRMLS_CC);
} else {
ZEPHIR_INIT_NVAR(name);
ZVAL_NULL(name);
}
ZEPHIR_CALL_FUNCTION(&_31, "urldecode", &_27, pathPart);
zephir_check_call_status();
ZEPHIR_CPY_WRT(pathPart, _31);
ZEPHIR_OBS_NVAR(part);
zephir_array_fetch(&part, parts, pos, PH_NOISY, "yaf/Route/rewrite.zep", 167 TSRMLS_CC);
ZEPHIR_SINIT_NVAR(_9);
ZVAL_LONG(&_9, 0);
ZEPHIR_SINIT_NVAR(_10);
ZVAL_LONG(&_10, 2);
ZEPHIR_INIT_NVAR(_2);
zephir_substr(_2, part, 0 , 2 , 0);
if (ZEPHIR_IS_STRING_IDENTICAL(_2, "@@")) {
ZEPHIR_SINIT_NVAR(_13);
ZVAL_LONG(&_13, 1);
ZEPHIR_INIT_NVAR(_11);
zephir_substr(_11, part, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH);
ZEPHIR_CPY_WRT(part, _11);
}
_28 = Z_TYPE_P(name) == IS_NULL;
if (_28) {
_28 = !ZEPHIR_IS_EQUAL(part, pathPart);
}
if (_28) {
RETURN_MM_BOOL(0);
}
_32 = Z_TYPE_P(part) != IS_NULL;
if (_32) {
ZEPHIR_INIT_LNVAR(_29);
ZEPHIR_CONCAT_VSSS(_29, part, "#^", "$#", "iu");
ZEPHIR_CALL_FUNCTION(&_31, "preg_match", &_33, _29, pathPart);
zephir_check_call_status();
_32 = !zephir_is_true(_31);
}
if (_32) {
RETURN_MM_BOOL(0);
}
if (Z_TYPE_P(name) != IS_NULL) {
zephir_array_update_zval(&values, name, &pathPart, PH_COPY | PH_SEPARATE);
} else {
pathStaticCount++;
}
}
}
if (staticCount != pathStaticCount) {
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_VAR(tmpReturn);
zephir_add_function_ex(tmpReturn, values, wildcardData TSRMLS_CC);
zephir_is_iterable(variables, &_35, &_34, 0, 0, "yaf/Route/rewrite.zep", 212);
for (
; zephir_hash_get_current_data_ex(_35, (void**) &_36, &_34) == SUCCESS
; zephir_hash_move_forward_ex(_35, &_34)
) {
ZEPHIR_GET_HVALUE(varr, _36);
if (!(zephir_array_key_exists(tmpReturn, varr TSRMLS_CC))) {
RETURN_MM_BOOL(0);
}
}
_12 = Z_TYPE_P(values) == IS_NULL;
if (_12) {
_12 = Z_TYPE_P(wildcardData) == IS_NULL;
}
_32 = _12;
if (_32) {
_32 = staticCount != 0;
}
if (_32) {
_3 = zephir_fetch_nproperty_this(this_ptr, SL("_default"), PH_NOISY_CC);
ZEPHIR_INIT_LNVAR(_24);
zephir_add_function_ex(_24, tmpReturn, _3 TSRMLS_CC);
ZEPHIR_CPY_WRT(tmpReturn, _24);
}
RETURN_CCTOR(tmpReturn);
}
PHP_METHOD(Phalcon_Http_Client_Header, build){
zval *flags = NULL, *messages, *status_code, *message = NULL, *version, *lines, *line = NULL;
zval *fields, *filed = NULL, *value = NULL, *join_filed;
HashTable *ah0;
HashPosition hp0;
zval **hd;
int f = 0;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 1, &flags);
if (flags) {
f = phalcon_get_intval(flags);
}
PHALCON_INIT_VAR(lines);
array_init(lines);
PHALCON_OBS_VAR(messages);
phalcon_read_static_property_ce(&messages, phalcon_http_client_header_ce, SL("_messages") TSRMLS_CC);
status_code = phalcon_fetch_nproperty_this(this_ptr, SL("_status_code"), PH_NOISY TSRMLS_CC);
if ((f & PHALCON_HTTP_CLIENT_HEADER_BUILD_STATUS) && phalcon_array_isset_fetch(&message, messages, status_code)) {
version = phalcon_fetch_nproperty_this(this_ptr, SL("_version "), PH_NOISY TSRMLS_CC);
PHALCON_INIT_NVAR(line);
PHALCON_CONCAT_SVS(line, "HTTP/", version, " ");
PHALCON_SCONCAT_VSV(line, status_code, " ", message);
phalcon_merge_append(lines, line);
}
fields = phalcon_fetch_nproperty_this(this_ptr, SL("_fields"), PH_NOISY TSRMLS_CC);
phalcon_is_iterable(fields, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(filed, ah0, hp0);
PHALCON_GET_HVALUE(value);
PHALCON_INIT_NVAR(line);
PHALCON_CONCAT_VSV(line, filed, ": ", value);
phalcon_merge_append(lines, line);
zend_hash_move_forward_ex(ah0, &hp0);
}
if (f & PHALCON_HTTP_CLIENT_HEADER_BUILD_FIELDS) {
PHALCON_INIT_VAR(join_filed);
phalcon_fast_join_str(join_filed, SL("\r\n"), lines TSRMLS_CC);
RETURN_CCTOR(join_filed);
}
RETURN_CCTOR(lines);
}
/**
* Returns an array of prepared attributes for Phalcon\Tag helpers
* according to the element parameters
*
* @param array attributes
* @param boolean useChecked
* @return array
*/
PHP_METHOD(Phalcon_Forms_Element, prepareAttributes) {
int ZEPHIR_LAST_CALL_STATUS;
zend_bool useChecked;
zval *attributes = NULL, *useChecked_param = NULL, *value = NULL, *name = NULL, *widgetAttributes = NULL, *mergedAttributes = NULL, *defaultAttributes = NULL, *currentValue = NULL, *_0$$10, *_1$$12;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 2, &attributes, &useChecked_param);
if (!attributes) {
attributes = ZEPHIR_GLOBAL(global_null);
}
if (!useChecked_param) {
useChecked = 0;
} else {
useChecked = zephir_get_boolval(useChecked_param);
}
ZEPHIR_OBS_VAR(name);
zephir_read_property_this(&name, this_ptr, SL("_name"), PH_NOISY_CC);
if (Z_TYPE_P(attributes) != IS_ARRAY) {
ZEPHIR_INIT_VAR(widgetAttributes);
array_init(widgetAttributes);
} else {
ZEPHIR_CPY_WRT(widgetAttributes, attributes);
}
zephir_array_update_long(&widgetAttributes, 0, &name, PH_COPY | PH_SEPARATE ZEPHIR_DEBUG_PARAMS_DUMMY);
ZEPHIR_OBS_VAR(defaultAttributes);
zephir_read_property_this(&defaultAttributes, this_ptr, SL("_attributes"), PH_NOISY_CC);
if (Z_TYPE_P(defaultAttributes) == IS_ARRAY) {
ZEPHIR_INIT_VAR(mergedAttributes);
zephir_fast_array_merge(mergedAttributes, &(defaultAttributes), &(widgetAttributes) TSRMLS_CC);
} else {
ZEPHIR_CPY_WRT(mergedAttributes, widgetAttributes);
}
ZEPHIR_CALL_METHOD(&value, this_ptr, "getvalue", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(value) != IS_NULL) {
if (useChecked) {
if (zephir_array_isset_string_fetch(¤tValue, mergedAttributes, SS("value"), 1 TSRMLS_CC)) {
if (ZEPHIR_IS_EQUAL(currentValue, value)) {
ZEPHIR_INIT_VAR(_0$$10);
ZVAL_STRING(_0$$10, "checked", 1);
zephir_array_update_string(&mergedAttributes, SL("checked"), &_0$$10, PH_COPY | PH_SEPARATE);
}
} else {
if (zephir_is_true(value)) {
ZEPHIR_INIT_VAR(_1$$12);
ZVAL_STRING(_1$$12, "checked", 1);
zephir_array_update_string(&mergedAttributes, SL("checked"), &_1$$12, PH_COPY | PH_SEPARATE);
}
zephir_array_update_string(&mergedAttributes, SL("value"), &value, PH_COPY | PH_SEPARATE);
}
} else {
zephir_array_update_string(&mergedAttributes, SL("value"), &value, PH_COPY | PH_SEPARATE);
}
}
RETURN_CCTOR(mergedAttributes);
}
/**
* Generates random text in accordance with the template
*
* <code>
* echo Phalcon\Text::dynamic("{Hi|Hello}, my name is a {Bob|Mark|Jon}!"); // Hi my name is a Bob
* echo Phalcon\Text::dynamic("{Hi|Hello}, my name is a {Bob|Mark|Jon}!"); // Hi my name is a Jon
* echo Phalcon\Text::dynamic("{Hi|Hello}, my name is a {Bob|Mark|Jon}!"); // Hello my name is a Bob
* </code>
*/
PHP_METHOD(Phalcon_Text, dynamic) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_1 = NULL, *_5 = NULL, *_8 = NULL;
zval *text_param = NULL, *leftDelimiter_param = NULL, *rightDelimiter_param = NULL, *separator_param = NULL, *ldS = NULL, *rdS = NULL, *result = NULL, *pattern = NULL, *_0 = NULL, *_2 = NULL, *_3$$3, *_6$$4 = NULL, *_7$$4 = NULL;
zval *text = NULL, *leftDelimiter = NULL, *rightDelimiter = NULL, *separator = NULL, *_4$$3;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 3, &text_param, &leftDelimiter_param, &rightDelimiter_param, &separator_param);
if (unlikely(Z_TYPE_P(text_param) != IS_STRING && Z_TYPE_P(text_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'text' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(text_param) == IS_STRING)) {
zephir_get_strval(text, text_param);
} else {
ZEPHIR_INIT_VAR(text);
ZVAL_EMPTY_STRING(text);
}
if (!leftDelimiter_param) {
ZEPHIR_INIT_VAR(leftDelimiter);
ZVAL_STRING(leftDelimiter, "{", 1);
} else {
if (unlikely(Z_TYPE_P(leftDelimiter_param) != IS_STRING && Z_TYPE_P(leftDelimiter_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'leftDelimiter' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(leftDelimiter_param) == IS_STRING)) {
zephir_get_strval(leftDelimiter, leftDelimiter_param);
} else {
ZEPHIR_INIT_VAR(leftDelimiter);
ZVAL_EMPTY_STRING(leftDelimiter);
}
}
if (!rightDelimiter_param) {
ZEPHIR_INIT_VAR(rightDelimiter);
ZVAL_STRING(rightDelimiter, "}", 1);
} else {
if (unlikely(Z_TYPE_P(rightDelimiter_param) != IS_STRING && Z_TYPE_P(rightDelimiter_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'rightDelimiter' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(rightDelimiter_param) == IS_STRING)) {
zephir_get_strval(rightDelimiter, rightDelimiter_param);
} else {
ZEPHIR_INIT_VAR(rightDelimiter);
ZVAL_EMPTY_STRING(rightDelimiter);
}
}
if (!separator_param) {
ZEPHIR_INIT_VAR(separator);
ZVAL_STRING(separator, "|", 1);
} else {
if (unlikely(Z_TYPE_P(separator_param) != IS_STRING && Z_TYPE_P(separator_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'separator' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(separator_param) == IS_STRING)) {
zephir_get_strval(separator, separator_param);
} else {
ZEPHIR_INIT_VAR(separator);
ZVAL_EMPTY_STRING(separator);
}
}
ZEPHIR_CALL_FUNCTION(&_0, "substr_count", &_1, 420, text, leftDelimiter);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&_2, "substr_count", &_1, 420, text, rightDelimiter);
zephir_check_call_status();
if (!ZEPHIR_IS_IDENTICAL(_0, _2)) {
ZEPHIR_INIT_VAR(_3$$3);
object_init_ex(_3$$3, spl_ce_RuntimeException);
ZEPHIR_INIT_VAR(_4$$3);
ZEPHIR_CONCAT_SVS(_4$$3, "Syntax error in string \"", text, "\"");
ZEPHIR_CALL_METHOD(NULL, _3$$3, "__construct", NULL, 421, _4$$3);
zephir_check_call_status();
zephir_throw_exception_debug(_3$$3, "phalcon/text.zep", 261 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_CALL_FUNCTION(&ldS, "preg_quote", &_5, 422, leftDelimiter);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&rdS, "preg_quote", &_5, 422, rightDelimiter);
zephir_check_call_status();
ZEPHIR_INIT_VAR(pattern);
ZEPHIR_CONCAT_SVSVVSVS(pattern, "/", ldS, "([^", ldS, rdS, "]+)", rdS, "/");
ZEPHIR_CPY_WRT(result, text);
while (1) {
if (!(zephir_memnstr(result, leftDelimiter, "phalcon/text.zep", 269))) {
break;
}
ZEPHIR_INIT_NVAR(_6$$4);
ZEPHIR_INIT_NVAR(_6$$4);
zephir_create_closure_ex(_6$$4, NULL, phalcon_0__closure_ce, SS("__invoke") TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_7$$4, "preg_replace_callback", &_8, 423, pattern, _6$$4, result);
zephir_check_call_status();
ZEPHIR_CPY_WRT(result, _7$$4);
}
RETURN_CCTOR(result);
}
/**
* Gets the column name in PostgreSQL
*/
PHP_METHOD(Phalcon_Db_Dialect_Postgresql, getColumnDefinition) {
zephir_nts_static zephir_fcall_cache_entry *_6 = NULL;
HashTable *_3;
HashPosition _2;
int ZEPHIR_LAST_CALL_STATUS;
zval *column, *size = NULL, *columnType = NULL, *columnSql, *typeValues = NULL, *_0 = NULL, *_1 = NULL, *value = NULL, *valueSql, **_4, _5 = zval_used_for_init, _7 = zval_used_for_init, *_8, *_9 = NULL, *_10 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &column);
ZEPHIR_CALL_METHOD(&size, column, "getsize", NULL);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&columnType, column, "gettype", NULL);
zephir_check_call_status();
ZEPHIR_INIT_VAR(columnSql);
ZVAL_STRING(columnSql, "", 1);
if (Z_TYPE_P(columnType) == IS_STRING) {
zephir_concat_self(&columnSql, columnType TSRMLS_CC);
ZEPHIR_CALL_METHOD(&columnType, column, "gettypereference", NULL);
zephir_check_call_status();
}
do {
if (ZEPHIR_IS_LONG(columnType, 0)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("INT") TSRMLS_CC);
}
break;
}
if (ZEPHIR_IS_LONG(columnType, 1)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("DATE") TSRMLS_CC);
}
break;
}
if (ZEPHIR_IS_LONG(columnType, 2)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("CHARACTER VARYING") TSRMLS_CC);
}
ZEPHIR_INIT_VAR(_0);
ZEPHIR_CONCAT_SVS(_0, "(", size, ")");
zephir_concat_self(&columnSql, _0 TSRMLS_CC);
break;
}
if (ZEPHIR_IS_LONG(columnType, 3)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("NUMERIC") TSRMLS_CC);
}
ZEPHIR_CALL_METHOD(&_1, column, "getscale", NULL);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_0);
ZEPHIR_CONCAT_SVSVS(_0, "(", size, ",", _1, ")");
zephir_concat_self(&columnSql, _0 TSRMLS_CC);
break;
}
if (ZEPHIR_IS_LONG(columnType, 4)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("TIMESTAMP") TSRMLS_CC);
}
break;
}
if (ZEPHIR_IS_LONG(columnType, 5)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("CHARACTER") TSRMLS_CC);
}
ZEPHIR_INIT_LNVAR(_0);
ZEPHIR_CONCAT_SVS(_0, "(", size, ")");
zephir_concat_self(&columnSql, _0 TSRMLS_CC);
break;
}
if (ZEPHIR_IS_LONG(columnType, 6)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("TEXT") TSRMLS_CC);
}
break;
}
if (ZEPHIR_IS_LONG(columnType, 7)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("FLOAT") TSRMLS_CC);
}
break;
}
if (ZEPHIR_IS_LONG(columnType, 8)) {
if (ZEPHIR_IS_EMPTY(columnSql)) {
zephir_concat_self_str(&columnSql, SL("SMALLINT(1)") TSRMLS_CC);
}
break;
}
if (ZEPHIR_IS_EMPTY(columnSql)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "Unrecognized PostgreSQL data type", "phalcon/db/dialect/postgresql.zep", 116);
return;
}
ZEPHIR_CALL_METHOD(&typeValues, column, "gettypevalues", NULL);
zephir_check_call_status();
if (!(ZEPHIR_IS_EMPTY(typeValues))) {
if (Z_TYPE_P(typeValues) == IS_ARRAY) {
ZEPHIR_INIT_VAR(valueSql);
ZVAL_STRING(valueSql, "", 1);
zephir_is_iterable(typeValues, &_3, &_2, 0, 0, "phalcon/db/dialect/postgresql.zep", 127);
for (
; zephir_hash_get_current_data_ex(_3, (void**) &_4, &_2) == SUCCESS
; zephir_hash_move_forward_ex(_3, &_2)
) {
ZEPHIR_GET_HVALUE(value, _4);
ZEPHIR_SINIT_NVAR(_5);
ZVAL_STRING(&_5, "\"", 0);
ZEPHIR_CALL_FUNCTION(&_1, "addcslashes", &_6, value, &_5);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_0);
ZEPHIR_CONCAT_SVS(_0, "\"", _1, "\", ");
zephir_concat_self(&valueSql, _0 TSRMLS_CC);
}
ZEPHIR_SINIT_NVAR(_5);
ZVAL_LONG(&_5, 0);
ZEPHIR_SINIT_VAR(_7);
ZVAL_LONG(&_7, -2);
ZEPHIR_INIT_VAR(_8);
zephir_substr(_8, valueSql, 0 , -2 , 0);
ZEPHIR_INIT_VAR(_9);
ZEPHIR_CONCAT_SVS(_9, "(", _8, ")");
zephir_concat_self(&columnSql, _9 TSRMLS_CC);
} else {
ZEPHIR_SINIT_NVAR(_7);
ZVAL_STRING(&_7, "\"", 0);
ZEPHIR_CALL_FUNCTION(&_10, "addcslashes", &_6, typeValues, &_7);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_9);
ZEPHIR_CONCAT_SVS(_9, "(\"", _10, "\")");
zephir_concat_self(&columnSql, _9 TSRMLS_CC);
}
}
} while(0);
RETURN_CCTOR(columnSql);
}
/**
* Gets number of rows returned by a resulset
*
*<code>
* $result = $connection->query("SELECT * FROM robots ORDER BY name");
* echo 'There are ', $result->numRows(), ' rows in the resulset';
*</code>
*
* @return int
*/
PHP_METHOD(Phalcon_Db_Result_Pdo, numRows){
zval *row_count = NULL, *connection, *type = NULL, *pdo_statement = NULL;
zval *sql_statement, *bind_params, *bind_types;
zval *matches, *pattern, *match, *else_clauses;
zval *sql, *result = NULL, *row = NULL;
PHALCON_MM_GROW();
PHALCON_OBS_VAR(row_count);
phalcon_read_property_this(&row_count, this_ptr, SL("_rowCount"), PH_NOISY TSRMLS_CC);
if (PHALCON_IS_FALSE(row_count)) {
PHALCON_OBS_VAR(connection);
phalcon_read_property_this(&connection, this_ptr, SL("_connection"), PH_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD(&type, connection, "gettype");
/**
* MySQL/PostgreSQL library property returns the number of records
*/
if (PHALCON_IS_STRING(type, "mysql") || PHALCON_IS_STRING(type, "pgsql")) {
PHALCON_OBS_VAR(pdo_statement);
phalcon_read_property_this(&pdo_statement, this_ptr, SL("_pdoStatement"), PH_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD(&row_count, pdo_statement, "rowcount");
}
/**
* We should get the count using a new statement :(
*/
if (PHALCON_IS_FALSE(row_count)) {
/**
* SQLite/Oracle/SQLServer returns resultsets that to the client eyes (PDO) has an
* arbitrary number of rows, so we need to perform an extra count to know that
*/
PHALCON_OBS_VAR(sql_statement);
phalcon_read_property_this(&sql_statement, this_ptr, SL("_sqlStatement"), PH_NOISY TSRMLS_CC);
/**
* If the sql_statement starts with SELECT COUNT(*) we don't make the count
*/
if (!phalcon_start_with_str(sql_statement, SL("SELECT COUNT(*) "))) {
PHALCON_OBS_VAR(bind_params);
phalcon_read_property_this(&bind_params, this_ptr, SL("_bindParams"), PH_NOISY TSRMLS_CC);
PHALCON_OBS_VAR(bind_types);
phalcon_read_property_this(&bind_types, this_ptr, SL("_bindTypes"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(matches);
PHALCON_INIT_VAR(pattern);
ZVAL_STRING(pattern, "/^SELECT\\s+(.*)$/i", 1);
PHALCON_INIT_VAR(match);
RETURN_MM_ON_FAILURE(phalcon_preg_match(match, pattern, sql_statement, matches TSRMLS_CC));
if (zend_is_true(match)) {
PHALCON_OBS_VAR(else_clauses);
phalcon_array_fetch_long(&else_clauses, matches, 1, PH_NOISY);
PHALCON_INIT_VAR(sql);
PHALCON_CONCAT_SVS(sql, "SELECT COUNT(*) \"numrows\" FROM (SELECT ", else_clauses, ")");
PHALCON_CALL_METHOD(&result, connection, "query", sql, bind_params, bind_types);
PHALCON_CALL_METHOD(&row, result, "fetch");
PHALCON_OBS_NVAR(row_count);
phalcon_array_fetch_string(&row_count, row, SL("numrows"), PH_NOISY);
}
} else {
PHALCON_INIT_NVAR(row_count);
ZVAL_LONG(row_count, 1);
}
}
/**
* Update the value to avoid further calculations
*/
phalcon_update_property_this(this_ptr, SL("_rowCount"), row_count TSRMLS_CC);
}
RETURN_CCTOR(row_count);
}
/**
* Magic method __get
*
* @param string $propertyName
*/
PHP_METHOD(Phalcon_DI_Injectable, __get){
zval *property_name, *dependency_injector = NULL;
zval *has_service, *service = NULL, *class_name, *arguments;
zval *persistent;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &property_name);
PHALCON_OBS_VAR(dependency_injector);
phalcon_read_property_this(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_INIT_NVAR(dependency_injector);
PHALCON_CALL_STATIC(dependency_injector, "phalcon\\di", "getdefault");
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_di_exception_ce, "A dependency injection object is required to access the application services");
return;
}
}
/**
* Fallback to the PHP userland if the cache is not available
*/
PHALCON_INIT_VAR(has_service);
phalcon_call_method_p1(has_service, dependency_injector, "has", property_name);
if (zend_is_true(has_service)) {
PHALCON_INIT_VAR(service);
phalcon_call_method_p1(service, dependency_injector, "getshared", property_name);
phalcon_update_property_zval_zval(this_ptr, property_name, service TSRMLS_CC);
RETURN_CCTOR(service);
}
if (PHALCON_IS_STRING(property_name, "di")) {
phalcon_update_property_this(this_ptr, SL("di"), dependency_injector TSRMLS_CC);
RETURN_CCTOR(dependency_injector);
}
/**
* Accessing the persistent property will create a session bag in any class
*/
if (PHALCON_IS_STRING(property_name, "persistent")) {
PHALCON_INIT_VAR(class_name);
phalcon_get_class(class_name, this_ptr, 0 TSRMLS_CC);
PHALCON_INIT_VAR(arguments);
array_init_size(arguments, 1);
phalcon_array_append(&arguments, class_name, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_NVAR(service);
ZVAL_STRING(service, "sessionBag", 1);
PHALCON_INIT_VAR(persistent);
phalcon_call_method_p2(persistent, dependency_injector, "get", service, arguments);
phalcon_update_property_this(this_ptr, SL("persistent"), persistent TSRMLS_CC);
RETURN_CCTOR(persistent);
}
/**
* A notice is shown if the property is not defined and isn't a valid service
*/
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Access to undefined property %s", Z_STRVAL_P(property_name));
RETURN_MM_NULL();
}
/**
* Internal handler to call a queue of events
*
* @param \SplPriorityQueue $queue
* @param Phalcon\Events\Event $event
* @return mixed
*/
PHP_METHOD(Phalcon_Events_Manager, fireQueue){
zval *queue, *event, *status = NULL, *arguments = NULL, *event_name;
zval *source, *data, *cancelable, *collect, *iterator;
zval *handler = NULL, *is_stopped = NULL;
zval *r0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &queue, &event);
if (unlikely(Z_TYPE_P(queue) != IS_ARRAY)) {
if (Z_TYPE_P(queue) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_events_exception_ce, "The SplPriorityQueue is not valid");
return;
}
}
if (unlikely(Z_TYPE_P(event) != IS_OBJECT)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_events_exception_ce, "The event is not valid");
return;
}
PHALCON_INIT_VAR(status);
PHALCON_INIT_VAR(arguments);
/**
* Get the event type
*/
PHALCON_INIT_VAR(event_name);
phalcon_call_method(event_name, event, "gettype");
if (unlikely(Z_TYPE_P(event_name) != IS_STRING)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_events_exception_ce, "The event type not valid");
return;
}
/**
* Get the object who triggered the event
*/
PHALCON_INIT_VAR(source);
phalcon_call_method(source, event, "getsource");
/**
* Get extra data passed to the event
*/
PHALCON_INIT_VAR(data);
phalcon_call_method(data, event, "getdata");
/**
* Tell if the event is cancelable
*/
PHALCON_INIT_VAR(cancelable);
phalcon_call_method(cancelable, event, "getcancelable");
/**
* Responses need to be traced?
*/
PHALCON_OBS_VAR(collect);
phalcon_read_property_this(&collect, this_ptr, SL("_collect"), PH_NOISY_CC);
if (Z_TYPE_P(queue) == IS_OBJECT) {
/**
* We need to clone the queue before iterate over it
*/
PHALCON_INIT_VAR(iterator);
if (phalcon_clone(iterator, queue TSRMLS_CC) == FAILURE) {
return;
}
/**
* Move the queue to the top
*/
phalcon_call_method_noret(iterator, "top");
while (1) {
PHALCON_INIT_NVAR(r0);
phalcon_call_method(r0, iterator, "valid");
if (zend_is_true(r0)) {
} else {
break;
}
/**
* Get the current data
*/
PHALCON_INIT_NVAR(handler);
phalcon_call_method(handler, iterator, "current");
/**
* Only handler objects are valid
*/
if (likely(Z_TYPE_P(handler) == IS_OBJECT)) {
/**
* Check if the event is a closure
*/
if (phalcon_is_instance_of(handler, SL("Closure") TSRMLS_CC)) {
/**
* Create the closure arguments
*/
if (Z_TYPE_P(arguments) == IS_NULL) {
PHALCON_INIT_NVAR(arguments);
array_init_size(arguments, 3);
phalcon_array_append(&arguments, event, PH_SEPARATE);
phalcon_array_append(&arguments, source, PH_SEPARATE);
phalcon_array_append(&arguments, data, PH_SEPARATE);
}
/**
* Call the function in the PHP userland
*/
PHALCON_INIT_NVAR(status);
PHALCON_CALL_USER_FUNC_ARRAY(status, handler, arguments);
/**
* Trace the response
*/
if (zend_is_true(collect)) {
phalcon_update_property_array_append(this_ptr, SL("_responses"), status TSRMLS_CC);
}
if (zend_is_true(cancelable)) {
/**
* Check if the event was stopped by the user
*/
PHALCON_INIT_NVAR(is_stopped);
phalcon_call_method(is_stopped, event, "isstopped");
if (zend_is_true(is_stopped)) {
break;
}
}
} else {
/**
* Check if the listener has implemented an event with the same name
*/
if (phalcon_method_exists(handler, event_name TSRMLS_CC) == SUCCESS) {
/**
* Call the function in the PHP userland
*/
PHALCON_INIT_NVAR(status);
phalcon_call_method_zval_p3(status, handler, event_name, event, source, data);
/**
* Collect the response
*/
if (zend_is_true(collect)) {
phalcon_update_property_array_append(this_ptr, SL("_responses"), status TSRMLS_CC);
}
if (zend_is_true(cancelable)) {
/**
* Check if the event was stopped by the user
*/
PHALCON_INIT_NVAR(is_stopped);
phalcon_call_method(is_stopped, event, "isstopped");
if (zend_is_true(is_stopped)) {
break;
}
}
}
}
}
/**
* Move the queue to the next handler
*/
phalcon_call_method_noret(iterator, "next");
}
} else {
phalcon_is_iterable(queue, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(handler);
/**
* Only handler objects are valid
*/
if (likely(Z_TYPE_P(handler) == IS_OBJECT)) {
/**
* Check if the event is a closure
*/
if (phalcon_is_instance_of(handler, SL("Closure") TSRMLS_CC)) {
/**
* Create the closure arguments
*/
if (Z_TYPE_P(arguments) == IS_NULL) {
PHALCON_INIT_NVAR(arguments);
array_init_size(arguments, 3);
phalcon_array_append(&arguments, event, PH_SEPARATE);
phalcon_array_append(&arguments, source, PH_SEPARATE);
phalcon_array_append(&arguments, data, PH_SEPARATE);
}
/**
* Call the function in the PHP userland
*/
PHALCON_INIT_NVAR(status);
PHALCON_CALL_USER_FUNC_ARRAY(status, handler, arguments);
/**
* Trace the response
*/
if (zend_is_true(collect)) {
phalcon_update_property_array_append(this_ptr, SL("_responses"), status TSRMLS_CC);
}
if (zend_is_true(cancelable)) {
/**
* Check if the event was stopped by the user
*/
PHALCON_INIT_NVAR(is_stopped);
phalcon_call_method(is_stopped, event, "isstopped");
if (zend_is_true(is_stopped)) {
break;
}
}
} else {
/**
* Check if the listener has implemented an event with the same name
*/
if (phalcon_method_exists(handler, event_name TSRMLS_CC) == SUCCESS) {
/**
* Call the function in the PHP userland
*/
PHALCON_INIT_NVAR(status);
phalcon_call_method_zval_p3(status, handler, event_name, event, source, data);
/**
* Collect the response
*/
if (zend_is_true(collect)) {
phalcon_update_property_array_append(this_ptr, SL("_responses"), status TSRMLS_CC);
}
if (zend_is_true(cancelable)) {
/**
* Check if the event was stopped by the user
*/
PHALCON_INIT_NVAR(is_stopped);
phalcon_call_method(is_stopped, event, "isstopped");
if (zend_is_true(is_stopped)) {
break;
}
}
}
}
}
zend_hash_move_forward_ex(ah0, &hp0);
}
}
RETURN_CCTOR(status);
}
/**
* Returns a slice of the resultset to show in the pagination
*/
PHP_METHOD(Phalcon_Paginator_Adapter_QueryBuilder, getPaginate) {
zval *_4$$8;
zval *originalBuilder = NULL, *builder = NULL, *totalBuilder = NULL, *totalPages = NULL, *limit = NULL, *number = NULL, *query = NULL, *page = NULL, *items = NULL, *totalQuery = NULL, *result = NULL, *row = NULL, *rowcount = NULL, *next = NULL, *_0, *_1 = NULL, *groups = NULL, *_6, _7, _8, *_9, *groupColumn$$8 = NULL, *_2$$8 = NULL, *_3$$8, *_5$$8;
int ZEPHIR_LAST_CALL_STATUS, numberPage = 0, before = 0;
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(originalBuilder);
zephir_read_property_this(&originalBuilder, this_ptr, SL("_builder"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(builder);
if (zephir_clone(builder, originalBuilder TSRMLS_CC) == FAILURE) {
RETURN_MM();
}
ZEPHIR_INIT_VAR(totalBuilder);
if (zephir_clone(totalBuilder, builder TSRMLS_CC) == FAILURE) {
RETURN_MM();
}
ZEPHIR_OBS_VAR(limit);
zephir_read_property_this(&limit, this_ptr, SL("_limitRows"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(_0);
zephir_read_property_this(&_0, this_ptr, SL("_page"), PH_NOISY_CC);
numberPage = zephir_get_intval(_0);
if (!(numberPage)) {
numberPage = 1;
}
ZEPHIR_INIT_VAR(number);
ZVAL_LONG(number, (zephir_get_numberval(limit) * ((numberPage - 1))));
if (ZEPHIR_LT(number, limit)) {
ZEPHIR_CALL_METHOD(NULL, builder, "limit", NULL, 0, limit);
zephir_check_call_status();
} else {
ZEPHIR_CALL_METHOD(NULL, builder, "limit", NULL, 0, limit, number);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(&query, builder, "getquery", NULL, 0);
zephir_check_call_status();
if (numberPage == 1) {
before = 1;
} else {
before = (numberPage - 1);
}
ZEPHIR_CALL_METHOD(&items, query, "execute", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "COUNT(*) [rowcount]", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, totalBuilder, "columns", NULL, 0, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&groups, totalBuilder, "getgroupby", NULL, 0);
zephir_check_call_status();
if (!(ZEPHIR_IS_EMPTY(groups))) {
if (Z_TYPE_P(groups) == IS_ARRAY) {
ZEPHIR_INIT_VAR(groupColumn$$8);
zephir_fast_join_str(groupColumn$$8, SL(", "), groups TSRMLS_CC);
} else {
ZEPHIR_CPY_WRT(groupColumn$$8, groups);
}
ZEPHIR_INIT_VAR(_3$$8);
ZVAL_NULL(_3$$8);
ZEPHIR_CALL_METHOD(&_2$$8, totalBuilder, "groupby", NULL, 0, _3$$8);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_4$$8);
zephir_create_array(_4$$8, 1, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_5$$8);
ZEPHIR_CONCAT_SVS(_5$$8, "COUNT(DISTINCT ", groupColumn$$8, ") AS rowcount");
zephir_array_fast_append(_4$$8, _5$$8);
ZEPHIR_CALL_METHOD(NULL, _2$$8, "columns", NULL, 0, _4$$8);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_1);
ZVAL_NULL(_1);
ZEPHIR_CALL_METHOD(NULL, totalBuilder, "orderby", NULL, 0, _1);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&totalQuery, totalBuilder, "getquery", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&result, totalQuery, "execute", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&row, result, "getfirst", NULL, 0);
zephir_check_call_status();
if (zephir_is_true(row)) {
ZEPHIR_OBS_VAR(_6);
zephir_read_property(&_6, row, SL("rowcount"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(rowcount);
ZVAL_LONG(rowcount, zephir_get_intval(_6));
} else {
ZEPHIR_INIT_NVAR(rowcount);
ZVAL_LONG(rowcount, 0);
}
ZEPHIR_SINIT_VAR(_7);
div_function(&_7, rowcount, limit TSRMLS_CC);
ZEPHIR_SINIT_VAR(_8);
ZVAL_DOUBLE(&_8, zephir_ceil(&_7 TSRMLS_CC));
ZEPHIR_INIT_VAR(totalPages);
ZVAL_LONG(totalPages, zephir_get_intval(&_8));
if (ZEPHIR_GT_LONG(totalPages, numberPage)) {
ZEPHIR_INIT_VAR(next);
ZVAL_LONG(next, (numberPage + 1));
} else {
ZEPHIR_CPY_WRT(next, totalPages);
}
ZEPHIR_INIT_VAR(page);
object_init(page);
zephir_update_property_zval(page, SL("items"), items TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_9);
ZVAL_LONG(_9, 1);
zephir_update_property_zval(page, SL("first"), _9 TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_9);
ZVAL_LONG(_9, before);
zephir_update_property_zval(page, SL("before"), _9 TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_9);
ZVAL_LONG(_9, numberPage);
zephir_update_property_zval(page, SL("current"), _9 TSRMLS_CC);
zephir_update_property_zval(page, SL("last"), totalPages TSRMLS_CC);
zephir_update_property_zval(page, SL("next"), next TSRMLS_CC);
zephir_update_property_zval(page, SL("total_pages"), totalPages TSRMLS_CC);
zephir_update_property_zval(page, SL("total_items"), rowcount TSRMLS_CC);
_9 = zephir_fetch_nproperty_this(this_ptr, SL("_limitRows"), PH_NOISY_CC);
zephir_update_property_zval(page, SL("limit"), _9 TSRMLS_CC);
RETURN_CCTOR(page);
}
/**
* Fires an event in the events manager causing that active listeners be notified about it
*
*<code>
* $eventsManager->fire('db', $connection);
*</code>
*
* @param string $eventType
* @param object $source
* @param mixed $data
* @param int $cancelable
* @return mixed
*/
PHP_METHOD(Phalcon_Events_Manager, fire){
zval *event_type, *source, *data = NULL, *cancelable = NULL, *events;
zval *exception_message, *event_parts, *type;
zval *event_name, *status = NULL, *collect, *event = NULL, *fire_events = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 2, &event_type, &source, &data, &cancelable);
if (!data) {
PHALCON_INIT_VAR(data);
}
if (!cancelable) {
PHALCON_INIT_VAR(cancelable);
ZVAL_BOOL(cancelable, 1);
}
if (unlikely(Z_TYPE_P(event_type) != IS_STRING)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_events_exception_ce, "Event type must be a string");
return;
}
PHALCON_OBS_VAR(events);
phalcon_read_property_this(&events, this_ptr, SL("_events"), PH_NOISY_CC);
if (Z_TYPE_P(events) != IS_ARRAY) {
RETURN_MM_NULL();
}
/**
* All valid events must have a colon separator
*/
if (!phalcon_memnstr_str(event_type, SL(":"))) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SV(exception_message, "Invalid event type ", event_type);
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_events_exception_ce, exception_message);
return;
}
PHALCON_INIT_VAR(event_parts);
phalcon_fast_explode_str(event_parts, SL(":"), event_type);
PHALCON_OBS_VAR(type);
phalcon_array_fetch_long(&type, event_parts, 0, PH_NOISY);
PHALCON_OBS_VAR(event_name);
phalcon_array_fetch_long(&event_name, event_parts, 1, PH_NOISY);
PHALCON_INIT_VAR(status);
/**
* Responses must be traced?
*/
PHALCON_OBS_VAR(collect);
phalcon_read_property_this(&collect, this_ptr, SL("_collect"), PH_NOISY_CC);
if (zend_is_true(collect)) {
phalcon_update_property_null(this_ptr, SL("_responses") TSRMLS_CC);
}
PHALCON_INIT_VAR(event);
/**
* Check if events are grouped by type
*/
if (phalcon_array_isset(events, type)) {
PHALCON_OBS_VAR(fire_events);
phalcon_array_fetch(&fire_events, events, type, PH_NOISY);
if (Z_TYPE_P(fire_events) == IS_ARRAY || Z_TYPE_P(fire_events) == IS_OBJECT) {
/**
* Create the event context
*/
object_init_ex(event, phalcon_events_event_ce);
phalcon_call_method_p4_noret(event, "__construct", event_name, source, data, cancelable);
/**
* Call the events queue
*/
phalcon_call_method_p2(status, this_ptr, "firequeue", fire_events, event);
}
}
/**
* Check if there are listeners for the event type itself
*/
if (phalcon_array_isset(events, event_type)) {
PHALCON_OBS_NVAR(fire_events);
phalcon_array_fetch(&fire_events, events, event_type, PH_NOISY);
if (Z_TYPE_P(fire_events) == IS_ARRAY || Z_TYPE_P(fire_events) == IS_OBJECT) {
/**
* Create the event if it wasn't created before
*/
if (Z_TYPE_P(event) == IS_NULL) {
PHALCON_INIT_NVAR(event);
object_init_ex(event, phalcon_events_event_ce);
phalcon_call_method_p4_noret(event, "__construct", event_name, source, data, cancelable);
}
/**
* Call the events queue
*/
PHALCON_INIT_NVAR(status);
phalcon_call_method_p2(status, this_ptr, "firequeue", fire_events, event);
}
}
RETURN_CCTOR(status);
}
/**
* Loads registered template engines, if none is registered it will use Phalcon\Mvc\View\Engine\Php
*
* @return array
*/
PHP_METHOD(Phalcon_Mvc_View_Simple, _loadTemplateEngines) {
zephir_fcall_cache_entry *_5 = NULL, *_7 = NULL;
HashTable *_3;
HashPosition _2;
zephir_nts_static zephir_fcall_cache_entry *_1 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *engines = NULL, *dependencyInjector, *registeredEngines, *arguments, *extension = NULL, *engineService = NULL, *engineObject = NULL, *_0 = NULL, **_4, *_6 = NULL;
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(engines);
zephir_read_property_this(&engines, this_ptr, SL("_engines"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(engines)) {
ZEPHIR_OBS_VAR(dependencyInjector);
zephir_read_property_this(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_INIT_NVAR(engines);
array_init(engines);
ZEPHIR_OBS_VAR(registeredEngines);
zephir_read_property_this(®isteredEngines, this_ptr, SL("_registeredEngines"), PH_NOISY_CC);
if (Z_TYPE_P(registeredEngines) != IS_ARRAY) {
ZEPHIR_INIT_VAR(_0);
object_init_ex(_0, phalcon_mvc_view_engine_php_ce);
ZEPHIR_CALL_METHOD(NULL, _0, "__construct", &_1, this_ptr, dependencyInjector);
zephir_check_call_status();
zephir_array_update_string(&engines, SL(".phtml"), &_0, PH_COPY | PH_SEPARATE);
} else {
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_view_exception_ce, "A dependency injector container is required to obtain the application services", "phalcon/mvc/view/simple.zep", 141);
return;
}
ZEPHIR_INIT_VAR(arguments);
zephir_create_array(arguments, 2, 0 TSRMLS_CC);
zephir_array_fast_append(arguments, this_ptr);
zephir_array_fast_append(arguments, dependencyInjector);
zephir_is_iterable(registeredEngines, &_3, &_2, 0, 0, "phalcon/mvc/view/simple.zep", 173);
for (
; zephir_hash_get_current_data_ex(_3, (void**) &_4, &_2) == SUCCESS
; zephir_hash_move_forward_ex(_3, &_2)
) {
ZEPHIR_GET_HMKEY(extension, _3, _2);
ZEPHIR_GET_HVALUE(engineService, _4);
if (Z_TYPE_P(engineService) == IS_OBJECT) {
if (zephir_instance_of_ev(engineService, zend_ce_closure TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(engineObject);
ZEPHIR_CALL_USER_FUNC_ARRAY(engineObject, engineService, arguments);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(engineObject, engineService);
}
} else {
if (Z_TYPE_P(engineService) == IS_STRING) {
ZEPHIR_CALL_METHOD(&engineObject, dependencyInjector, "getshared", &_5, engineService, arguments);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(_0);
object_init_ex(_0, phalcon_mvc_view_exception_ce);
ZEPHIR_INIT_LNVAR(_6);
ZEPHIR_CONCAT_SV(_6, "Invalid template engine registration for extension: ", extension);
ZEPHIR_CALL_METHOD(NULL, _0, "__construct", &_7, _6);
zephir_check_call_status();
zephir_throw_exception_debug(_0, "phalcon/mvc/view/simple.zep", 167 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
}
zephir_array_update_zval(&engines, extension, &engineObject, PH_COPY | PH_SEPARATE);
}
}
zephir_update_property_this(this_ptr, SL("_engines"), engines TSRMLS_CC);
} else {
ZEPHIR_OBS_NVAR(engines);
zephir_read_property_this(&engines, this_ptr, SL("_engines"), PH_NOISY_CC);
}
RETURN_CCTOR(engines);
}
/**
* Assigns values to a row from an array returning a new row
*
* @param array $result
* @return Phalcon\Mvc\Model $result
*/
PHP_METHOD(Phalcon_Mvc_Model_Row, dumpResult){
zval *result = NULL, *object_row = NULL, *columns = NULL, *value = NULL, *field = NULL;
zval *i0 = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL;
zval *r0 = NULL, *r1 = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &result) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_ALLOC_ZVAL_MM(i0);
if (phalcon_clone(i0, this_ptr TSRMLS_CC) == FAILURE){
return;
}
PHALCON_CPY_WRT(object_row, i0);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_columns"), PH_NOISY_CC);
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_fast_count(r0, t0 TSRMLS_CC);
PHALCON_INIT_VAR(t1);
ZVAL_LONG(t1, 0);
PHALCON_ALLOC_ZVAL_MM(r1);
is_equal_function(r1, r0, t1 TSRMLS_CC);
if (zend_is_true(r1)) {
PHALCON_INIT_VAR(columns);
array_init(columns);
if (!phalcon_valid_foreach(result TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(result);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_4c15_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_4c15_0;
}
PHALCON_INIT_VAR(field);
PHALCON_GET_FOREACH_KEY(field, ah0, hp0);
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
phalcon_array_update_zval_bool(&columns, field, 1, PH_SEPARATE TSRMLS_CC);
phalcon_update_property_zval_zval(object_row, field, value TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_4c15_0;
fee_4c15_0:
if(0){}
phalcon_update_property_zval(object_row, SL("_columns"), columns TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_columns"), columns TSRMLS_CC);
} else {
if (!phalcon_valid_foreach(result TSRMLS_CC)) {
return;
}
ah1 = Z_ARRVAL_P(result);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
fes_4c15_1:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_4c15_1;
}
PHALCON_INIT_VAR(field);
PHALCON_GET_FOREACH_KEY(field, ah1, hp1);
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
phalcon_update_property_zval_zval(object_row, field, value TSRMLS_CC);
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_4c15_1;
fee_4c15_1:
if(0){}
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, SL("_columns"), PH_NOISY_CC);
phalcon_update_property_zval(object_row, SL("_columns"), t2 TSRMLS_CC);
}
RETURN_CCTOR(object_row);
}
/**
* Generates a random string based on the given type. Type is one of the RANDOM_* constants
*
* <code>
* echo Phalcon\Text::random(Phalcon\Text::RANDOM_ALNUM); //"aloiwkqz"
* </code>
*/
PHP_METHOD(Phalcon_Text, random) {
zephir_fcall_cache_entry *_3 = NULL, *_18 = NULL;
long length;
zval *type_param = NULL, *length_param = NULL, *pool = NULL, *str = NULL, _0$$3 = zval_used_for_init, _1$$3 = zval_used_for_init, *_2$$3 = NULL, *_4$$3 = NULL, _5$$4 = zval_used_for_init, _6$$4 = zval_used_for_init, *_7$$4 = NULL, *_8$$4 = NULL, _9$$5, _10$$5, _11$$6, _12$$6, _13$$7 = zval_used_for_init, _14$$7 = zval_used_for_init, *_15$$7 = NULL, *_16$$7 = NULL, *_17$$7 = NULL, *_19$$8, _20$$8 = zval_used_for_init, _21$$8 = zval_used_for_init;
int type, ZEPHIR_LAST_CALL_STATUS, end = 0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 2, &type_param, &length_param);
if (!type_param) {
type = 0;
} else {
type = zephir_get_intval(type_param);
}
if (!length_param) {
length = 8;
} else {
length = zephir_get_intval(length_param);
}
ZEPHIR_INIT_VAR(str);
ZVAL_STRING(str, "", 1);
do {
if (type == 1) {
ZEPHIR_SINIT_VAR(_0$$3);
ZVAL_STRING(&_0$$3, "a", 0);
ZEPHIR_SINIT_VAR(_1$$3);
ZVAL_STRING(&_1$$3, "z", 0);
ZEPHIR_CALL_FUNCTION(&_2$$3, "range", &_3, 441, &_0$$3, &_1$$3);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_0$$3);
ZVAL_STRING(&_0$$3, "A", 0);
ZEPHIR_SINIT_NVAR(_1$$3);
ZVAL_STRING(&_1$$3, "Z", 0);
ZEPHIR_CALL_FUNCTION(&_4$$3, "range", &_3, 441, &_0$$3, &_1$$3);
zephir_check_call_status();
ZEPHIR_INIT_VAR(pool);
zephir_fast_array_merge(pool, &(_2$$3), &(_4$$3) TSRMLS_CC);
break;
}
if (type == 2) {
ZEPHIR_SINIT_VAR(_5$$4);
ZVAL_LONG(&_5$$4, 0);
ZEPHIR_SINIT_VAR(_6$$4);
ZVAL_LONG(&_6$$4, 9);
ZEPHIR_CALL_FUNCTION(&_7$$4, "range", &_3, 441, &_5$$4, &_6$$4);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_5$$4);
ZVAL_STRING(&_5$$4, "a", 0);
ZEPHIR_SINIT_NVAR(_6$$4);
ZVAL_STRING(&_6$$4, "f", 0);
ZEPHIR_CALL_FUNCTION(&_8$$4, "range", &_3, 441, &_5$$4, &_6$$4);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(pool);
zephir_fast_array_merge(pool, &(_7$$4), &(_8$$4) TSRMLS_CC);
break;
}
if (type == 3) {
ZEPHIR_SINIT_VAR(_9$$5);
ZVAL_LONG(&_9$$5, 0);
ZEPHIR_SINIT_VAR(_10$$5);
ZVAL_LONG(&_10$$5, 9);
ZEPHIR_CALL_FUNCTION(&pool, "range", &_3, 441, &_9$$5, &_10$$5);
zephir_check_call_status();
break;
}
if (type == 4) {
ZEPHIR_SINIT_VAR(_11$$6);
ZVAL_LONG(&_11$$6, 1);
ZEPHIR_SINIT_VAR(_12$$6);
ZVAL_LONG(&_12$$6, 9);
ZEPHIR_CALL_FUNCTION(&pool, "range", &_3, 441, &_11$$6, &_12$$6);
zephir_check_call_status();
break;
}
ZEPHIR_SINIT_VAR(_13$$7);
ZVAL_LONG(&_13$$7, 0);
ZEPHIR_SINIT_VAR(_14$$7);
ZVAL_LONG(&_14$$7, 9);
ZEPHIR_CALL_FUNCTION(&_15$$7, "range", &_3, 441, &_13$$7, &_14$$7);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_13$$7);
ZVAL_STRING(&_13$$7, "a", 0);
ZEPHIR_SINIT_NVAR(_14$$7);
ZVAL_STRING(&_14$$7, "z", 0);
ZEPHIR_CALL_FUNCTION(&_16$$7, "range", &_3, 441, &_13$$7, &_14$$7);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_13$$7);
ZVAL_STRING(&_13$$7, "A", 0);
ZEPHIR_SINIT_NVAR(_14$$7);
ZVAL_STRING(&_14$$7, "Z", 0);
ZEPHIR_CALL_FUNCTION(&_17$$7, "range", &_3, 441, &_13$$7, &_14$$7);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&pool, "array_merge", &_18, 442, _15$$7, _16$$7, _17$$7);
zephir_check_call_status();
break;
} while(0);
end = (zephir_fast_count_int(pool TSRMLS_CC) - 1);
while (1) {
if (!(zephir_fast_strlen_ev(str) < length)) {
break;
}
ZEPHIR_SINIT_NVAR(_20$$8);
ZVAL_LONG(&_20$$8, 0);
ZEPHIR_SINIT_NVAR(_21$$8);
ZVAL_LONG(&_21$$8, end);
zephir_array_fetch_long(&_19$$8, pool, zephir_mt_rand(zephir_get_intval(&_20$$8), zephir_get_intval(&_21$$8) TSRMLS_CC), PH_NOISY | PH_READONLY, "phalcon/text.zep", 129 TSRMLS_CC);
zephir_concat_self(&str, _19$$8 TSRMLS_CC);
}
RETURN_CCTOR(str);
}
/**
* Returns a slice of the resultset to show in the pagination
*/
PHP_METHOD(Phalcon_Paginator_Adapter_QueryBuilder, getPaginate) {
int numberPage, before, ZEPHIR_LAST_CALL_STATUS;
zval *originalBuilder, *builder, *totalBuilder, *totalPages, *limit, *number, *query = NULL, *page, *items = NULL, *totalQuery = NULL, *result = NULL, *row = NULL, *rowcount, *next = NULL, *_0, *_1 = NULL, *_2, _3, _4, *_5;
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(originalBuilder);
zephir_read_property_this(&originalBuilder, this_ptr, SL("_builder"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(builder);
if (zephir_clone(builder, originalBuilder TSRMLS_CC) == FAILURE) {
RETURN_MM();
}
ZEPHIR_INIT_VAR(totalBuilder);
if (zephir_clone(totalBuilder, builder TSRMLS_CC) == FAILURE) {
RETURN_MM();
}
ZEPHIR_OBS_VAR(limit);
zephir_read_property_this(&limit, this_ptr, SL("_limitRows"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(_0);
zephir_read_property_this(&_0, this_ptr, SL("_page"), PH_NOISY_CC);
numberPage = zephir_get_intval(_0);
if (!(numberPage)) {
numberPage = 1;
}
ZEPHIR_INIT_VAR(number);
ZVAL_LONG(number, (zephir_get_numberval(limit) * ((numberPage - 1))));
if (ZEPHIR_LT(number, limit)) {
ZEPHIR_CALL_METHOD(NULL, builder, "limit", NULL, 0, limit);
zephir_check_call_status();
} else {
ZEPHIR_CALL_METHOD(NULL, builder, "limit", NULL, 0, limit, number);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(&query, builder, "getquery", NULL, 0);
zephir_check_call_status();
if (numberPage == 1) {
before = 1;
} else {
before = (numberPage - 1);
}
ZEPHIR_CALL_METHOD(&items, query, "execute", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "COUNT(*) [rowcount]", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, totalBuilder, "columns", NULL, 0, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_1);
ZVAL_NULL(_1);
ZEPHIR_CALL_METHOD(NULL, totalBuilder, "orderby", NULL, 0, _1);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&totalQuery, totalBuilder, "getquery", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&result, totalQuery, "execute", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&row, result, "getfirst", NULL, 0);
zephir_check_call_status();
ZEPHIR_OBS_VAR(_2);
zephir_read_property(&_2, row, SL("rowcount"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(rowcount);
ZVAL_LONG(rowcount, zephir_get_intval(_2));
ZEPHIR_SINIT_VAR(_3);
div_function(&_3, rowcount, limit TSRMLS_CC);
ZEPHIR_SINIT_VAR(_4);
ZVAL_DOUBLE(&_4, zephir_ceil(&_3 TSRMLS_CC));
ZEPHIR_INIT_VAR(totalPages);
ZVAL_LONG(totalPages, zephir_get_intval(&_4));
if (ZEPHIR_GT_LONG(totalPages, numberPage)) {
ZEPHIR_INIT_VAR(next);
ZVAL_LONG(next, (numberPage + 1));
} else {
ZEPHIR_CPY_WRT(next, totalPages);
}
ZEPHIR_INIT_VAR(page);
object_init(page);
zephir_update_property_zval(page, SL("items"), items TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_5);
ZVAL_LONG(_5, 1);
zephir_update_property_zval(page, SL("first"), _5 TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_5);
ZVAL_LONG(_5, before);
zephir_update_property_zval(page, SL("before"), _5 TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_5);
ZVAL_LONG(_5, numberPage);
zephir_update_property_zval(page, SL("current"), _5 TSRMLS_CC);
zephir_update_property_zval(page, SL("last"), totalPages TSRMLS_CC);
zephir_update_property_zval(page, SL("next"), next TSRMLS_CC);
zephir_update_property_zval(page, SL("total_pages"), totalPages TSRMLS_CC);
zephir_update_property_zval(page, SL("total_items"), rowcount TSRMLS_CC);
_5 = zephir_fetch_nproperty_this(this_ptr, SL("_limitRows"), PH_NOISY_CC);
zephir_update_property_zval(page, SL("limit"), _5 TSRMLS_CC);
RETURN_CCTOR(page);
}
/**
* Traverses a collection calling the callback to generate its HTML
*
* @param Phalcon\Assets\Collection $collection
* @param callback $callback
* @param string $type
* @param array $args
*/
PHP_METHOD(Phalcon_Assets_Manager, output){
zval *collection, *callback, *type = NULL, *args = NULL, *output, *use_implicit_output;
zval *resources = NULL, *filters = NULL, *prefix = NULL, *source_base_path = NULL;
zval *target_base_path = NULL, *options, *collection_source_path = NULL;
zval *complete_source_path = NULL, *collection_target_path = NULL;
zval *complete_target_path = NULL, *filtered_joined_content = NULL;
zval *join = NULL, *exception_message = NULL, *is_directory;
zval *resource = NULL, *filter_needed = NULL, *local = NULL, *source_path = NULL;
zval *target_path = NULL, *path = NULL, *prefixed_path = NULL, *attributes = NULL;
zval *parameters = NULL, *html = NULL, *content = NULL, *must_filter = NULL;
zval *filter = NULL, *filtered_content = NULL, *target_uri = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
zval *type_css;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 2, &collection, &callback, &type, &args);
if (!args) {
args = PHALCON_GLOBAL(z_null);
}
PHALCON_INIT_VAR(output);
PHALCON_OBS_VAR(use_implicit_output);
phalcon_read_property_this(&use_implicit_output, this_ptr, SL("_implicitOutput"), PH_NOISY TSRMLS_CC);
/**
* Get the resources as an array
*/
PHALCON_CALL_METHOD(&resources, collection, "getresources");
/**
* Get filters in the collection
*/
PHALCON_CALL_METHOD(&filters, collection, "getfilters");
/**
* Get the collection's prefix
*/
PHALCON_CALL_METHOD(&prefix, collection, "getprefix");
PHALCON_INIT_VAR(type_css);
ZVAL_STRING(type_css, "css", 1);
/**
* Prepare options if the collection must be filtered
*/
if (Z_TYPE_P(filters) == IS_ARRAY) {
PHALCON_INIT_VAR(source_base_path);
PHALCON_INIT_VAR(target_base_path);
PHALCON_OBS_VAR(options);
phalcon_read_property_this(&options, this_ptr, SL("_options"), PH_NOISY TSRMLS_CC);
/**
* Check for global options in the assets manager
*/
if (Z_TYPE_P(options) == IS_ARRAY) {
/**
* The source base path is a global location where all resources are located
*/
if (phalcon_array_isset_string(options, SS("sourceBasePath"))) {
PHALCON_OBS_NVAR(source_base_path);
phalcon_array_fetch_string(&source_base_path, options, SL("sourceBasePath"), PH_NOISY);
}
/**
* The target base path is a global location where all resources are written
*/
if (phalcon_array_isset_string(options, SS("targetBasePath"))) {
PHALCON_OBS_NVAR(target_base_path);
phalcon_array_fetch_string(&target_base_path, options, SL("targetBasePath"), PH_NOISY);
}
}
/**
* Check if the collection have its own source base path
*/
PHALCON_CALL_METHOD(&collection_source_path, collection, "getsourcepath");
/**
* Concatenate the global base source path with the collection one
*/
if (PHALCON_IS_NOT_EMPTY(collection_source_path)) {
PHALCON_INIT_VAR(complete_source_path);
PHALCON_CONCAT_VV(complete_source_path, source_base_path, collection_source_path);
} else {
PHALCON_CPY_WRT(complete_source_path, source_base_path);
}
/**
* Check if the collection have its own target base path
*/
PHALCON_CALL_METHOD(&collection_target_path, collection, "gettargetpath");
/**
* Concatenate the global base source path with the collection one
*/
if (PHALCON_IS_NOT_EMPTY(collection_target_path)) {
PHALCON_INIT_VAR(complete_target_path);
PHALCON_CONCAT_VV(complete_target_path, target_base_path, collection_target_path);
} else {
PHALCON_CPY_WRT(complete_target_path, target_base_path);
}
/**
* Global filtered content
*/
PHALCON_INIT_VAR(filtered_joined_content);
/**
* Check if all the resources in the collection must be joined
*/
PHALCON_CALL_METHOD(&join, collection, "getjoin");
/**
* Check for valid target paths if the collection must be joined
*/
if (zend_is_true(join)) {
/**
* We need a valid final target path
*/
if (PHALCON_IS_EMPTY(complete_target_path)) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Path '", complete_target_path, "' is not a valid target path (1)");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_assets_exception_ce, exception_message);
return;
}
PHALCON_INIT_VAR(is_directory);
phalcon_is_dir(is_directory, complete_target_path TSRMLS_CC);
/**
* The targetpath needs to be a valid file
*/
if (PHALCON_IS_TRUE(is_directory)) {
PHALCON_INIT_NVAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Path '", complete_target_path, "' is not a valid target path (2)");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_assets_exception_ce, exception_message);
return;
}
}
}
phalcon_is_iterable(resources, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(resource);
PHALCON_INIT_NVAR(filter_needed);
ZVAL_FALSE(filter_needed);
if (!type) {
PHALCON_CALL_METHOD(&type, resource, "gettype");
}
/**
* Is the resource local?
*/
PHALCON_CALL_METHOD(&local, resource, "getlocal");
/**
* If the collection must not be joined we must print a HTML for each one
*/
if (Z_TYPE_P(filters) == IS_ARRAY) {
if (zend_is_true(local)) {
/**
* Get the complete path
*/
PHALCON_CALL_METHOD(&source_path, resource, "getrealsourcepath", complete_source_path);
/**
* We need a valid source path
*/
if (!zend_is_true(source_path)) {
PHALCON_CALL_METHOD(&source_path, resource, "getpath");
PHALCON_INIT_NVAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Resource '", source_path, "' does not have a valid source path");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_assets_exception_ce, exception_message);
return;
}
} else {
/**
* Get the complete source path
*/
PHALCON_CALL_METHOD(&source_path, resource, "getpath");
/**
* resources paths are always filtered
*/
PHALCON_INIT_NVAR(filter_needed);
ZVAL_TRUE(filter_needed);
}
/**
* Get the target path, we need to write the filtered content to a file
*/
PHALCON_CALL_METHOD(&target_path, resource, "getrealtargetpath", complete_target_path);
/**
* We need a valid final target path
*/
if (PHALCON_IS_EMPTY(target_path)) {
PHALCON_INIT_NVAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Resource '", source_path, "' does not have a valid target path");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_assets_exception_ce, exception_message);
return;
}
if (zend_is_true(local)) {
/**
* Make sure the target path is not the same source path
*/
if (PHALCON_IS_EQUAL(target_path, source_path)) {
PHALCON_INIT_NVAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Resource '", target_path, "' have the same source and target paths");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_assets_exception_ce, exception_message);
return;
}
if (phalcon_file_exists(target_path TSRMLS_CC) == SUCCESS) {
if (phalcon_compare_mtime(target_path, source_path TSRMLS_CC)) {
PHALCON_INIT_NVAR(filter_needed);
ZVAL_TRUE(filter_needed);
}
} else {
PHALCON_INIT_NVAR(filter_needed);
ZVAL_TRUE(filter_needed);
}
}
}
/**
* If there are no filters, just print/buffer the HTML
*/
if (Z_TYPE_P(filters) != IS_ARRAY) {
PHALCON_CALL_METHOD(&path, resource, "getrealtargeturi");
if (Z_TYPE_P(prefix) != IS_NULL) {
PHALCON_INIT_NVAR(prefixed_path);
PHALCON_CONCAT_VV(prefixed_path, prefix, path);
} else {
PHALCON_CPY_WRT(prefixed_path, path);
}
/**
* Gets extra HTML attributes in the resource
*/
PHALCON_CALL_METHOD(&attributes, resource, "getattributes");
/**
* Prepare the parameters for the callback
*/
PHALCON_INIT_NVAR(parameters);
array_init_size(parameters, 3);
if (Z_TYPE_P(attributes) == IS_ARRAY) {
phalcon_array_update_long(&attributes, 0, prefixed_path, PH_COPY);
phalcon_array_append(¶meters, attributes, PH_COPY);
} else {
phalcon_array_append(¶meters, prefixed_path, PH_COPY);
}
phalcon_array_append(¶meters, local, PH_COPY);
phalcon_array_append(¶meters, args, PH_COPY);
/**
* Call the callback to generate the HTML
*/
PHALCON_INIT_NVAR(html);/**/
PHALCON_CALL_USER_FUNC_ARRAY(html, callback, parameters);
/**
* Implicit output prints the content directly
*/
if (zend_is_true(use_implicit_output)) {
zend_print_zval(html, 0);
} else {
phalcon_concat_self(&output, html TSRMLS_CC);
}
zend_hash_move_forward_ex(ah0, &hp0);
continue;
}
if (zend_is_true(filter_needed)) {
/**
* Get the resource's content
*/
PHALCON_CALL_METHOD(&content, resource, "getcontent", complete_source_path);
/**
* Check if the resource must be filtered
*/
PHALCON_CALL_METHOD(&must_filter, resource, "getfilter");
/**
* Only filter the resource if it's marked as 'filterable'
*/
if (zend_is_true(must_filter)) {
phalcon_is_iterable(filters, &ah1, &hp1, 0, 0);
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_HVALUE(filter);
/**
* Filters must be valid objects
*/
if (Z_TYPE_P(filter) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_assets_exception_ce, "Filter is invalid");
return;
}
/**
* Calls the method 'filter' which must return a filtered version of the content
*/
PHALCON_CALL_METHOD(&filtered_content, filter, "filter", content);
PHALCON_CPY_WRT_CTOR(content, filtered_content);
zend_hash_move_forward_ex(ah1, &hp1);
}
/**
* Update the joined filtered content
*/
if (zend_is_true(join)) {
if (PHALCON_IS_EQUAL(type, type_css)) {
if (Z_TYPE_P(filtered_joined_content) == IS_NULL) {
PHALCON_INIT_NVAR(filtered_joined_content);
PHALCON_CONCAT_VS(filtered_joined_content, content, "");
} else {
PHALCON_SCONCAT_VS(filtered_joined_content, content, "");
}
} else {
if (Z_TYPE_P(filtered_joined_content) == IS_NULL) {
PHALCON_INIT_NVAR(filtered_joined_content);
PHALCON_CONCAT_VS(filtered_joined_content, content, ";");
} else {
PHALCON_SCONCAT_VS(filtered_joined_content, content, ";");
}
}
}
} else {
/**
* Update the joined filtered content
*/
if (zend_is_true(join)) {
if (Z_TYPE_P(filtered_joined_content) == IS_NULL) {
PHALCON_CPY_WRT(filtered_joined_content, content);
} else {
phalcon_concat_self(&filtered_joined_content, content TSRMLS_CC);
}
} else {
PHALCON_CPY_WRT(filtered_content, content);
}
}
if (!zend_is_true(join)) {
/**
* Write the file using file-put-contents. This respects the openbase-dir also
* writes to streams
*/
phalcon_file_put_contents(NULL, target_path, filtered_content TSRMLS_CC);
}
}
if (!zend_is_true(join)) {
/**
* Generate the HTML using the original path in the resource
*/
PHALCON_CALL_METHOD(&path, resource, "getrealtargeturi");
if (Z_TYPE_P(prefix) != IS_NULL) {
PHALCON_INIT_NVAR(prefixed_path);
PHALCON_CONCAT_VV(prefixed_path, prefix, path);
} else {
PHALCON_CPY_WRT(prefixed_path, path);
}
/**
* Gets extra HTML attributes in the resource
*/
PHALCON_CALL_METHOD(&attributes, resource, "getattributes");
/**
* Filtered resources are always local
*/
PHALCON_INIT_NVAR(local);
ZVAL_TRUE(local);
/**
* Prepare the parameters for the callback
*/
PHALCON_INIT_NVAR(parameters);
array_init_size(parameters, 3);
if (Z_TYPE_P(attributes) == IS_ARRAY) {
phalcon_array_update_long(&attributes, 0, prefixed_path, PH_COPY);
phalcon_array_append(¶meters, attributes, PH_COPY);
} else {
phalcon_array_append(¶meters, prefixed_path, PH_COPY);
}
phalcon_array_append(¶meters, local, PH_COPY);
phalcon_array_append(¶meters, args, PH_COPY);
/**
* Call the callback to generate the HTML
*/
PHALCON_INIT_NVAR(html);/**/
PHALCON_CALL_USER_FUNC_ARRAY(html, callback, parameters);
/**
* Implicit output prints the content directly
*/
if (zend_is_true(use_implicit_output)) {
zend_print_zval(html, 0);
} else {
phalcon_concat_self(&output, html TSRMLS_CC);
}
}
zend_hash_move_forward_ex(ah0, &hp0);
}
if (Z_TYPE_P(filters) == IS_ARRAY) {
if (zend_is_true(join)) {
/**
* Write the file using file_put_contents. This respects the openbase-dir also
* writes to streams
*/
phalcon_file_put_contents(NULL, complete_target_path, filtered_joined_content TSRMLS_CC);
/**
* Generate the HTML using the original path in the resource
*/
PHALCON_CALL_METHOD(&target_uri, collection, "gettargeturi");
if (Z_TYPE_P(prefix) != IS_NULL) {
PHALCON_INIT_NVAR(prefixed_path);
PHALCON_CONCAT_VV(prefixed_path, prefix, target_uri);
} else {
PHALCON_CPY_WRT(prefixed_path, target_uri);
}
/**
* Gets extra HTML attributes in the resource
*/
PHALCON_CALL_METHOD(&attributes, collection, "getattributes");
PHALCON_CALL_METHOD(&local, collection, "gettargetlocal");
/**
* Prepare the parameters for the callback
*/
PHALCON_INIT_NVAR(parameters);
array_init_size(parameters, 3);
if (Z_TYPE_P(attributes) == IS_ARRAY) {
phalcon_array_update_long(&attributes, 0, prefixed_path, PH_COPY);
phalcon_array_append(¶meters, attributes, PH_COPY);
} else {
phalcon_array_append(¶meters, prefixed_path, PH_COPY);
}
phalcon_array_append(¶meters, local, PH_COPY);
phalcon_array_append(¶meters, args, PH_COPY);
/**
* Call the callback to generate the HTML
*/
PHALCON_INIT_NVAR(html);/**/
PHALCON_CALL_USER_FUNC_ARRAY(html, callback, parameters);
/**
* Implicit output prints the content directly
*/
if (zend_is_true(use_implicit_output)) {
zend_print_zval(html, 0);
} else {
phalcon_concat_self(&output, html TSRMLS_CC);
}
}
}
RETURN_CCTOR(output);
}
/**
* Returns a cached content
*/
PHP_METHOD(Phalcon_Cache_Backend_File, get) {
int lifetime, ZEPHIR_LAST_CALL_STATUS, ttl = 0, modifiedTime = 0;
zval *keyName_param = NULL, *lifetime_param = NULL, *prefixedKey = NULL, *cacheDir = NULL, *cacheFile = NULL, *frontend = NULL, *lastLifetime = NULL, *cachedContent = NULL, *ret = NULL, *_0, *_1 = NULL, *_2, *_3$$6 = NULL, *_4$$4, *_5$$4, *_6$$10, *_7$$10;
zval *keyName = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &keyName_param, &lifetime_param);
zephir_get_strval(keyName, keyName_param);
if (!lifetime_param) {
lifetime = 0;
} else {
lifetime = zephir_get_intval(lifetime_param);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&_1, this_ptr, "getkey", NULL, 0, keyName);
zephir_check_call_status();
ZEPHIR_INIT_VAR(prefixedKey);
ZEPHIR_CONCAT_VV(prefixedKey, _0, _1);
zephir_update_property_this(this_ptr, SL("_lastKey"), prefixedKey TSRMLS_CC);
ZEPHIR_OBS_VAR(cacheDir);
_2 = zephir_fetch_nproperty_this(this_ptr, SL("_options"), PH_NOISY_CC);
if (!(zephir_array_isset_string_fetch(&cacheDir, _2, SS("cacheDir"), 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options", "phalcon/cache/backend/file.zep", 111);
return;
}
ZEPHIR_INIT_VAR(cacheFile);
ZEPHIR_CONCAT_VV(cacheFile, cacheDir, prefixedKey);
if ((zephir_file_exists(cacheFile TSRMLS_CC) == SUCCESS) == 1) {
ZEPHIR_OBS_VAR(frontend);
zephir_read_property_this(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC);
if (!(lifetime)) {
ZEPHIR_OBS_VAR(lastLifetime);
zephir_read_property_this(&lastLifetime, this_ptr, SL("_lastLifetime"), PH_NOISY_CC);
if (!(zephir_is_true(lastLifetime))) {
ZEPHIR_CALL_METHOD(&_3$$6, frontend, "getlifetime", NULL, 0);
zephir_check_call_status();
ttl = zephir_get_intval(_3$$6);
} else {
ttl = zephir_get_intval(lastLifetime);
}
} else {
ttl = lifetime;
}
ZEPHIR_CALL_FUNCTION(NULL, "clearstatcache", NULL, 114, ZEPHIR_GLOBAL(global_true), cacheFile);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_4$$4);
zephir_filemtime(_4$$4, cacheFile TSRMLS_CC);
modifiedTime = zephir_get_intval(_4$$4);
ZEPHIR_INIT_VAR(_5$$4);
zephir_time(_5$$4);
if (ZEPHIR_LT_LONG(_5$$4, (modifiedTime + ttl))) {
ZEPHIR_INIT_VAR(cachedContent);
zephir_file_get_contents(cachedContent, cacheFile TSRMLS_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(cachedContent)) {
ZEPHIR_INIT_VAR(_6$$10);
object_init_ex(_6$$10, phalcon_cache_exception_ce);
ZEPHIR_INIT_VAR(_7$$10);
ZEPHIR_CONCAT_SVS(_7$$10, "Cache file ", cacheFile, " could not be opened");
ZEPHIR_CALL_METHOD(NULL, _6$$10, "__construct", NULL, 9, _7$$10);
zephir_check_call_status();
zephir_throw_exception_debug(_6$$10, "phalcon/cache/backend/file.zep", 148 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
if (zephir_is_numeric(cachedContent)) {
RETURN_CCTOR(cachedContent);
} else {
ZEPHIR_CALL_METHOD(&ret, frontend, "afterretrieve", NULL, 0, cachedContent);
zephir_check_call_status();
RETURN_CCTOR(ret);
}
}
}
RETURN_MM_NULL();
}
/**
* Applies the internal format to the message
*
* @param string $message
* @param int $type
* @param int $time
* @return string
*/
PHP_METHOD(Phalcon_Logger_Adapter_File, _applyFormat){
zval *message = NULL, *type = NULL, *time = NULL, *format = NULL;
zval *c0 = NULL, *c1 = NULL, *c2 = NULL;
zval *t0 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &message, &type, &time) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!time) {
PHALCON_ALLOC_ZVAL_MM(time);
ZVAL_LONG(time, 0);
} else {
PHALCON_SEPARATE_PARAM(time);
}
if (!zend_is_true(time)) {
PHALCON_INIT_VAR(time);
PHALCON_CALL_FUNC(time, "time");
}
PHALCON_INIT_VAR(format);
phalcon_read_property(&format, this_ptr, SL("_format"), PH_NOISY_CC);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "%date%", 1);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_dateFormat"), PH_NOISY_CC);
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_FUNC_PARAMS_2(r0, "date", t0, time);
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_fast_str_replace(r1, c0, r0, format TSRMLS_CC);
PHALCON_CPY_WRT(format, r1);
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, "%type%", 1);
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_CALL_METHOD_PARAMS_1(r2, this_ptr, "gettypestring", type, PH_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(r3);
phalcon_fast_str_replace(r3, c1, r2, format TSRMLS_CC);
PHALCON_CPY_WRT(format, r3);
PHALCON_INIT_VAR(c2);
ZVAL_STRING(c2, "%message%", 1);
PHALCON_ALLOC_ZVAL_MM(r4);
phalcon_fast_str_replace(r4, c2, message, format TSRMLS_CC);
PHALCON_CPY_WRT(format, r4);
RETURN_CCTOR(format);
}
/**
* Stores cached content into the file backend and stops the frontend
*
* @param int|string keyName
* @param string content
* @param int lifetime
* @param boolean stopBuffer
*/
PHP_METHOD(Phalcon_Cache_Backend_File, save) {
int ZEPHIR_LAST_CALL_STATUS;
zend_bool stopBuffer;
zval *keyName = NULL, *content = NULL, *lifetime = NULL, *stopBuffer_param = NULL, *lastKey = NULL, *frontend = NULL, *cacheDir = NULL, *isBuffering = NULL, *cacheFile = NULL, *cachedContent = NULL, *preparedContent = NULL, *status = NULL, *_2, *_0$$4, *_1$$4 = NULL, *_3$$11, *_4$$11;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 4, &keyName, &content, &lifetime, &stopBuffer_param);
if (!keyName) {
keyName = ZEPHIR_GLOBAL(global_null);
}
if (!content) {
content = ZEPHIR_GLOBAL(global_null);
}
if (!lifetime) {
lifetime = ZEPHIR_GLOBAL(global_null);
}
if (!stopBuffer_param) {
stopBuffer = 1;
} else {
stopBuffer = zephir_get_boolval(stopBuffer_param);
}
if (Z_TYPE_P(keyName) == IS_NULL) {
ZEPHIR_OBS_VAR(lastKey);
zephir_read_property_this(&lastKey, this_ptr, SL("_lastKey"), PH_NOISY_CC);
} else {
_0$$4 = zephir_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&_1$$4, this_ptr, "getkey", NULL, 0, keyName);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(lastKey);
ZEPHIR_CONCAT_VV(lastKey, _0$$4, _1$$4);
zephir_update_property_this(this_ptr, SL("_lastKey"), lastKey TSRMLS_CC);
}
if (!(zephir_is_true(lastKey))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Cache must be started first", "phalcon/cache/backend/file.zep", 186);
return;
}
ZEPHIR_OBS_VAR(frontend);
zephir_read_property_this(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(cacheDir);
_2 = zephir_fetch_nproperty_this(this_ptr, SL("_options"), PH_NOISY_CC);
if (!(zephir_array_isset_string_fetch(&cacheDir, _2, SS("cacheDir"), 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options", "phalcon/cache/backend/file.zep", 192);
return;
}
ZEPHIR_INIT_VAR(cacheFile);
ZEPHIR_CONCAT_VV(cacheFile, cacheDir, lastKey);
if (Z_TYPE_P(content) == IS_NULL) {
ZEPHIR_CALL_METHOD(&cachedContent, frontend, "getcontent", NULL, 0);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(cachedContent, content);
}
if (!(zephir_is_numeric(cachedContent))) {
ZEPHIR_CALL_METHOD(&preparedContent, frontend, "beforestore", NULL, 0, cachedContent);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(preparedContent, cachedContent);
}
ZEPHIR_INIT_VAR(status);
zephir_file_put_contents(status, cacheFile, preparedContent TSRMLS_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(status)) {
ZEPHIR_INIT_VAR(_3$$11);
object_init_ex(_3$$11, phalcon_cache_exception_ce);
ZEPHIR_INIT_VAR(_4$$11);
ZEPHIR_CONCAT_SVS(_4$$11, "Cache file ", cacheFile, " could not be written");
ZEPHIR_CALL_METHOD(NULL, _3$$11, "__construct", NULL, 9, _4$$11);
zephir_check_call_status();
zephir_throw_exception_debug(_3$$11, "phalcon/cache/backend/file.zep", 215 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_CALL_METHOD(&isBuffering, frontend, "isbuffering", NULL, 0);
zephir_check_call_status();
if (stopBuffer == 1) {
ZEPHIR_CALL_METHOD(NULL, frontend, "stop", NULL, 0);
zephir_check_call_status();
}
if (ZEPHIR_IS_TRUE_IDENTICAL(isBuffering)) {
zend_print_zval(cachedContent, 0);
}
if (0) {
zephir_update_property_this(this_ptr, SL("_started"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
} else {
zephir_update_property_this(this_ptr, SL("_started"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
}
RETURN_CCTOR(status);
}
/**
* Handle the whole command-line tasks
*
* @param array arguments
* @return mixed
*/
PHP_METHOD(Phalcon_Cli_Console, handle) {
zephir_nts_static zephir_fcall_cache_entry *_6 = NULL;
zend_bool _3;
int ZEPHIR_LAST_CALL_STATUS;
zval *arguments = NULL, *dependencyInjector, *router = NULL, *eventsManager = NULL, *moduleName = NULL, *modules, *module, *path, *className = NULL, *moduleObject = NULL, *dispatcher = NULL, *task = NULL, *_0, *_1 = NULL, *_2 = NULL, *_4, *_5 = NULL, *_7 = NULL, *_8 = NULL, *_9 = NULL, *_10 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &arguments);
if (!arguments) {
arguments = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_OBS_VAR(dependencyInjector);
zephir_read_property_this(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cli_console_exception_ce, "A dependency injection object is required to access internal services", "phalcon/cli/console.zep", 171);
return;
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_eventsManager"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(eventsManager, _0);
ZEPHIR_INIT_VAR(_2);
ZVAL_STRING(_2, "router", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_1, dependencyInjector, "getshared", NULL, _2);
zephir_check_temp_parameter(_2);
zephir_check_call_status();
ZEPHIR_CPY_WRT(router, _1);
_3 = !zephir_is_true(arguments);
if (_3) {
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_arguments"), PH_NOISY_CC);
_3 = zephir_is_true(_0);
}
if (_3) {
_4 = zephir_fetch_nproperty_this(this_ptr, SL("_arguments"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, router, "handle", NULL, _4);
zephir_check_call_status();
} else {
ZEPHIR_CALL_METHOD(NULL, router, "handle", NULL, arguments);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(&moduleName, router, "getmodulename", NULL);
zephir_check_call_status();
if (zephir_is_true(moduleName)) {
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "console:beforeStartModule", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_1, eventsManager, "fire", NULL, _2, this_ptr, moduleName);
zephir_check_temp_parameter(_2);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_1)) {
RETURN_MM_BOOL(0);
}
}
ZEPHIR_OBS_VAR(modules);
zephir_read_property_this(&modules, this_ptr, SL("_modules"), PH_NOISY_CC);
if (!(zephir_array_isset(modules, moduleName))) {
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_cli_console_exception_ce);
ZEPHIR_INIT_VAR(_5);
ZEPHIR_CONCAT_SVS(_5, "Module '", moduleName, "' isn't registered in the console container");
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, _5);
zephir_check_call_status();
zephir_throw_exception_debug(_2, "phalcon/cli/console.zep", 195 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_OBS_VAR(module);
zephir_array_fetch(&module, modules, moduleName, PH_NOISY, "phalcon/cli/console.zep", 198 TSRMLS_CC);
if (Z_TYPE_P(module) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cli_console_exception_ce, "Invalid module definition path", "phalcon/cli/console.zep", 200);
return;
}
ZEPHIR_OBS_VAR(path);
if (zephir_array_isset_string_fetch(&path, module, SS("path"), 0 TSRMLS_CC)) {
if (!((zephir_file_exists(path TSRMLS_CC) == SUCCESS))) {
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_cli_console_exception_ce);
ZEPHIR_INIT_LNVAR(_5);
ZEPHIR_CONCAT_SVS(_5, "Module definition path '", path, "' doesn't exist");
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, _5);
zephir_check_call_status();
zephir_throw_exception_debug(_2, "phalcon/cli/console.zep", 205 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
if (zephir_require_zval(path TSRMLS_CC) == FAILURE) {
RETURN_MM_NULL();
}
}
ZEPHIR_OBS_VAR(className);
if (!(zephir_array_isset_string_fetch(&className, module, SS("className"), 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(className);
ZVAL_STRING(className, "Module", 1);
}
ZEPHIR_CALL_METHOD(&moduleObject, dependencyInjector, "get", NULL, className);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, moduleObject, "registerautoloaders", NULL);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, moduleObject, "registerservices", NULL, dependencyInjector);
zephir_check_call_status();
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
zephir_update_property_this(this_ptr, SL("_moduleObject"), moduleObject TSRMLS_CC);
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "console:afterStartModule", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_7, eventsManager, "fire", NULL, _2, this_ptr, moduleObject);
zephir_check_temp_parameter(_2);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_7)) {
RETURN_MM_BOOL(0);
}
}
}
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "dispatcher", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_7, dependencyInjector, "getshared", NULL, _2);
zephir_check_temp_parameter(_2);
zephir_check_call_status();
ZEPHIR_CPY_WRT(dispatcher, _7);
ZEPHIR_CALL_METHOD(&_7, router, "gettaskname", NULL);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, dispatcher, "settaskname", NULL, _7);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_8, router, "getactionname", NULL);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, dispatcher, "setactionname", NULL, _8);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_9, router, "getparams", NULL);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, dispatcher, "setparams", NULL, _9);
zephir_check_call_status();
_4 = zephir_fetch_nproperty_this(this_ptr, SL("_options"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, dispatcher, "setoptions", NULL, _4);
zephir_check_call_status();
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "console:beforeHandleTask", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_10, eventsManager, "fire", NULL, _2, this_ptr, dispatcher);
zephir_check_temp_parameter(_2);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_10)) {
RETURN_MM_BOOL(0);
}
}
ZEPHIR_CALL_METHOD(&task, dispatcher, "dispatch", NULL);
zephir_check_call_status();
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "console:afterHandleTask", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, _2, this_ptr, task);
zephir_check_temp_parameter(_2);
zephir_check_call_status();
}
RETURN_CCTOR(task);
}
/**
* Sends SQL statements to the database server returning the success state.
* Use this method only when the SQL statement sent to the server is returning rows
*
*<code>
* //Querying data
* $resultset = $connection->query("SELECT * FROM robots WHERE type='mechanical'");
* $resultset = $connection->query("SELECT * FROM robots WHERE type=?", array("mechanical"));
*</code>
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, query) {
int ZEPHIR_LAST_CALL_STATUS;
zval *sqlStatement_param = NULL, *bindParams = NULL, *bindTypes = NULL, *eventsManager = NULL, *pdo = NULL, *statement = NULL, *_0, *_1$$3 = NULL, *_2$$3, *_3$$6 = NULL, *_4$$9;
zval *sqlStatement = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 2, &sqlStatement_param, &bindParams, &bindTypes);
if (unlikely(Z_TYPE_P(sqlStatement_param) != IS_STRING && Z_TYPE_P(sqlStatement_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'sqlStatement' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(sqlStatement_param) == IS_STRING)) {
zephir_get_strval(sqlStatement, sqlStatement_param);
} else {
ZEPHIR_INIT_VAR(sqlStatement);
ZVAL_EMPTY_STRING(sqlStatement);
}
if (!bindParams) {
bindParams = ZEPHIR_GLOBAL(global_null);
}
if (!bindTypes) {
bindTypes = ZEPHIR_GLOBAL(global_null);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_eventsManager"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(eventsManager, _0);
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
zephir_update_property_this(this_ptr, SL("_sqlStatement"), sqlStatement TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_sqlVariables"), bindParams TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_sqlBindTypes"), bindTypes TSRMLS_CC);
ZEPHIR_INIT_VAR(_2$$3);
ZVAL_STRING(_2$$3, "db:beforeQuery", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_1$$3, eventsManager, "fire", NULL, 0, _2$$3, this_ptr);
zephir_check_temp_parameter(_2$$3);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_1$$3)) {
RETURN_MM_BOOL(0);
}
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_pdo"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(pdo, _0);
if (Z_TYPE_P(bindParams) == IS_ARRAY) {
ZEPHIR_CALL_METHOD(&statement, pdo, "prepare", NULL, 0, sqlStatement);
zephir_check_call_status();
if (Z_TYPE_P(statement) == IS_OBJECT) {
ZEPHIR_CALL_METHOD(&_3$$6, this_ptr, "executeprepared", NULL, 0, statement, bindParams, bindTypes);
zephir_check_call_status();
ZEPHIR_CPY_WRT(statement, _3$$6);
}
} else {
ZEPHIR_CALL_METHOD(&statement, pdo, "query", NULL, 0, sqlStatement);
zephir_check_call_status();
}
if (Z_TYPE_P(statement) == IS_OBJECT) {
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_4$$9);
ZVAL_STRING(_4$$9, "db:afterQuery", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, 0, _4$$9, this_ptr);
zephir_check_temp_parameter(_4$$9);
zephir_check_call_status();
}
object_init_ex(return_value, phalcon_db_result_pdo_ce);
ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 37, this_ptr, statement, sqlStatement, bindParams, bindTypes);
zephir_check_call_status();
RETURN_MM();
}
RETURN_CCTOR(statement);
}
/**
* Gets the a value to validate in the array/object data source
*
* @param string field
* @return mixed
*/
PHP_METHOD(Phalcon_Validation, getValue) {
zephir_fcall_cache_entry *_2 = NULL;
zend_bool _1;
int ZEPHIR_LAST_CALL_STATUS;
zval *field_param = NULL, *entity, *method = NULL, *value = NULL, *data, *values, *filters, *fieldFilters, *dependencyInjector = NULL, *filterService = NULL, *_3;
zval *field = NULL, *_0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &field_param);
zephir_get_strval(field, field_param);
ZEPHIR_OBS_VAR(entity);
zephir_read_property_this(&entity, this_ptr, SL("_entity"), PH_NOISY_CC);
if (Z_TYPE_P(entity) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_0);
ZEPHIR_CONCAT_SV(_0, "get", field);
ZEPHIR_CPY_WRT(method, _0);
if ((zephir_method_exists(entity, method TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD_ZVAL(&value, entity, method, NULL, 0);
zephir_check_call_status();
} else {
if ((zephir_method_exists_ex(entity, SS("readattribute") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD(&value, entity, "readattribute", NULL, 0, field);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(value);
if (zephir_isset_property_zval(entity, field TSRMLS_CC)) {
zephir_read_property_zval(&value, entity, field, PH_NOISY_CC);
} else {
ZVAL_NULL(value);
}
}
}
RETURN_CCTOR(value);
}
ZEPHIR_OBS_VAR(data);
zephir_read_property_this(&data, this_ptr, SL("_data"), PH_NOISY_CC);
_1 = Z_TYPE_P(data) != IS_ARRAY;
if (_1) {
_1 = Z_TYPE_P(data) != IS_OBJECT;
}
if (_1) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "There is no data to validate", "phalcon/validation.zep", 386);
return;
}
ZEPHIR_OBS_VAR(values);
zephir_read_property_this(&values, this_ptr, SL("_values"), PH_NOISY_CC);
ZEPHIR_OBS_NVAR(value);
if (zephir_array_isset_fetch(&value, values, field, 0 TSRMLS_CC)) {
RETURN_CCTOR(value);
}
ZEPHIR_INIT_NVAR(value);
ZVAL_NULL(value);
if (Z_TYPE_P(data) == IS_ARRAY) {
if (zephir_array_isset(data, field)) {
ZEPHIR_OBS_NVAR(value);
zephir_array_fetch(&value, data, field, PH_NOISY, "phalcon/validation.zep", 400 TSRMLS_CC);
}
} else if (Z_TYPE_P(data) == IS_OBJECT) {
if (zephir_isset_property_zval(data, field TSRMLS_CC)) {
ZEPHIR_OBS_NVAR(value);
zephir_read_property_zval(&value, data, field, PH_NOISY_CC);
}
}
if (Z_TYPE_P(value) == IS_NULL) {
RETURN_MM_NULL();
}
ZEPHIR_OBS_VAR(filters);
zephir_read_property_this(&filters, this_ptr, SL("_filters"), PH_NOISY_CC);
if (Z_TYPE_P(filters) == IS_ARRAY) {
ZEPHIR_OBS_VAR(fieldFilters);
if (zephir_array_isset_fetch(&fieldFilters, filters, field, 0 TSRMLS_CC)) {
if (zephir_is_true(fieldFilters)) {
ZEPHIR_CALL_METHOD(&dependencyInjector, this_ptr, "getdi", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_CALL_CE_STATIC(&dependencyInjector, phalcon_di_ce, "getdefault", &_2, 145);
zephir_check_call_status();
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "A dependency injector is required to obtain the 'filter' service", "phalcon/validation.zep", 423);
return;
}
}
ZEPHIR_INIT_VAR(_3);
ZVAL_STRING(_3, "filter", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&filterService, dependencyInjector, "getshared", NULL, 0, _3);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
if (Z_TYPE_P(filterService) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Returned 'filter' service is invalid", "phalcon/validation.zep", 429);
return;
}
ZEPHIR_RETURN_CALL_METHOD(filterService, "sanitize", NULL, 0, value, fieldFilters);
zephir_check_call_status();
RETURN_MM();
}
}
}
zephir_update_property_array(this_ptr, SL("_values"), field, value TSRMLS_CC);
RETURN_CCTOR(value);
}
/**
* Returns an array of Phalcon\Db\Column objects describing a table
*
* <code>
* print_r($connection->describeColumns("posts"));
* </code>
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Mysql, describeColumns) {
HashTable *_5;
HashPosition _4;
zephir_fcall_cache_entry *_41 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *table_param = NULL, *schema_param = NULL, *columns = NULL, *columnType = NULL, *field = NULL, *definition = NULL, *oldColumn = NULL, *sizePattern = NULL, *matches = NULL, *matchOne = NULL, *matchTwo = NULL, *columnName = NULL, *_0 = NULL, *_1, *_2 = NULL, *_3, **_6, *_7$$5 = NULL, *_8$$5 = NULL, *_9$$6 = NULL, *_10$$6 = NULL, *_11$$7 = NULL, *_12$$8 = NULL, *_13$$9 = NULL, *_14$$10 = NULL, *_15$$11 = NULL, *_16$$12 = NULL, *_17$$13 = NULL, *_18$$14 = NULL, *_19$$14 = NULL, *_20$$15 = NULL, *_21$$15 = NULL, *_22$$16 = NULL, *_23$$16 = NULL, *_24$$17 = NULL, *_25$$17 = NULL, *_26$$18 = NULL, *_27$$18 = NULL, *_28$$19 = NULL, *_29$$20 = NULL, *_30$$21 = NULL, *_31$$4 = NULL, *_32$$22 = NULL, *_33$$24 = NULL, *_34$$25 = NULL, *_35$$3, *_36$$3, *_37$$3, *_38$$3 = NULL, *_40$$3 = NULL, *_39$$32;
zval *table = NULL, *schema = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &table_param, &schema_param);
zephir_get_strval(table, table_param);
if (!schema_param) {
ZEPHIR_INIT_VAR(schema);
ZVAL_EMPTY_STRING(schema);
} else {
zephir_get_strval(schema, schema_param);
}
ZEPHIR_INIT_VAR(oldColumn);
ZVAL_NULL(oldColumn);
ZEPHIR_INIT_VAR(sizePattern);
ZVAL_STRING(sizePattern, "#\\(([0-9]+)(?:,\\s*([0-9]+))*\\)#", 1);
ZEPHIR_INIT_VAR(columns);
array_init(columns);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_dialect"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&_2, _1, "describecolumns", NULL, 0, table, schema);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_3);
ZVAL_LONG(_3, 3);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "fetchall", NULL, 0, _2, _3);
zephir_check_call_status();
zephir_is_iterable(_0, &_5, &_4, 0, 0, "phalcon/db/adapter/pdo/mysql.zep", 345);
for (
; zephir_hash_get_current_data_ex(_5, (void**) &_6, &_4) == SUCCESS
; zephir_hash_move_forward_ex(_5, &_4)
) {
ZEPHIR_GET_HVALUE(field, _6);
ZEPHIR_INIT_NVAR(definition);
zephir_create_array(definition, 1, 0 TSRMLS_CC);
add_assoc_long_ex(definition, SS("bindType"), 2);
ZEPHIR_OBS_NVAR(columnType);
zephir_array_fetch_long(&columnType, field, 1, PH_NOISY, "phalcon/db/adapter/pdo/mysql.zep", 119 TSRMLS_CC);
while (1) {
if (zephir_memnstr_str(columnType, SL("bigint"), "phalcon/db/adapter/pdo/mysql.zep", 126)) {
ZEPHIR_INIT_NVAR(_7$$5);
ZVAL_LONG(_7$$5, 14);
zephir_array_update_string(&definition, SL("type"), &_7$$5, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&definition, SL("isNumeric"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_8$$5);
ZVAL_LONG(_8$$5, 1);
zephir_array_update_string(&definition, SL("bindType"), &_8$$5, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("int"), "phalcon/db/adapter/pdo/mysql.zep", 136)) {
ZEPHIR_INIT_NVAR(_9$$6);
ZVAL_LONG(_9$$6, 0);
zephir_array_update_string(&definition, SL("type"), &_9$$6, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&definition, SL("isNumeric"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_10$$6);
ZVAL_LONG(_10$$6, 1);
zephir_array_update_string(&definition, SL("bindType"), &_10$$6, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("varchar"), "phalcon/db/adapter/pdo/mysql.zep", 146)) {
ZEPHIR_INIT_NVAR(_11$$7);
ZVAL_LONG(_11$$7, 2);
zephir_array_update_string(&definition, SL("type"), &_11$$7, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("datetime"), "phalcon/db/adapter/pdo/mysql.zep", 154)) {
ZEPHIR_INIT_NVAR(_12$$8);
ZVAL_LONG(_12$$8, 4);
zephir_array_update_string(&definition, SL("type"), &_12$$8, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("enum"), "phalcon/db/adapter/pdo/mysql.zep", 162)) {
ZEPHIR_INIT_NVAR(_13$$9);
ZVAL_LONG(_13$$9, 5);
zephir_array_update_string(&definition, SL("type"), &_13$$9, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("char"), "phalcon/db/adapter/pdo/mysql.zep", 170)) {
ZEPHIR_INIT_NVAR(_14$$10);
ZVAL_LONG(_14$$10, 5);
zephir_array_update_string(&definition, SL("type"), &_14$$10, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("date"), "phalcon/db/adapter/pdo/mysql.zep", 178)) {
ZEPHIR_INIT_NVAR(_15$$11);
ZVAL_LONG(_15$$11, 1);
zephir_array_update_string(&definition, SL("type"), &_15$$11, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("timestamp"), "phalcon/db/adapter/pdo/mysql.zep", 186)) {
ZEPHIR_INIT_NVAR(_16$$12);
ZVAL_LONG(_16$$12, 17);
zephir_array_update_string(&definition, SL("type"), &_16$$12, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("text"), "phalcon/db/adapter/pdo/mysql.zep", 194)) {
ZEPHIR_INIT_NVAR(_17$$13);
ZVAL_LONG(_17$$13, 6);
zephir_array_update_string(&definition, SL("type"), &_17$$13, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("decimal"), "phalcon/db/adapter/pdo/mysql.zep", 202)) {
ZEPHIR_INIT_NVAR(_18$$14);
ZVAL_LONG(_18$$14, 3);
zephir_array_update_string(&definition, SL("type"), &_18$$14, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&definition, SL("isNumeric"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_19$$14);
ZVAL_LONG(_19$$14, 32);
zephir_array_update_string(&definition, SL("bindType"), &_19$$14, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("double"), "phalcon/db/adapter/pdo/mysql.zep", 212)) {
ZEPHIR_INIT_NVAR(_20$$15);
ZVAL_LONG(_20$$15, 9);
zephir_array_update_string(&definition, SL("type"), &_20$$15, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&definition, SL("isNumeric"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_21$$15);
ZVAL_LONG(_21$$15, 32);
zephir_array_update_string(&definition, SL("bindType"), &_21$$15, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("float"), "phalcon/db/adapter/pdo/mysql.zep", 222)) {
ZEPHIR_INIT_NVAR(_22$$16);
ZVAL_LONG(_22$$16, 7);
zephir_array_update_string(&definition, SL("type"), &_22$$16, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&definition, SL("isNumeric"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_23$$16);
ZVAL_LONG(_23$$16, 32);
zephir_array_update_string(&definition, SL("bindType"), &_23$$16, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("bit"), "phalcon/db/adapter/pdo/mysql.zep", 232)) {
ZEPHIR_INIT_NVAR(_24$$17);
ZVAL_LONG(_24$$17, 8);
zephir_array_update_string(&definition, SL("type"), &_24$$17, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_25$$17);
ZVAL_LONG(_25$$17, 5);
zephir_array_update_string(&definition, SL("bindType"), &_25$$17, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("tinyblob"), "phalcon/db/adapter/pdo/mysql.zep", 241)) {
ZEPHIR_INIT_NVAR(_26$$18);
ZVAL_LONG(_26$$18, 10);
zephir_array_update_string(&definition, SL("type"), &_26$$18, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_27$$18);
ZVAL_LONG(_27$$18, 5);
zephir_array_update_string(&definition, SL("bindType"), &_27$$18, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("mediumblob"), "phalcon/db/adapter/pdo/mysql.zep", 250)) {
ZEPHIR_INIT_NVAR(_28$$19);
ZVAL_LONG(_28$$19, 12);
zephir_array_update_string(&definition, SL("type"), &_28$$19, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("longblob"), "phalcon/db/adapter/pdo/mysql.zep", 258)) {
ZEPHIR_INIT_NVAR(_29$$20);
ZVAL_LONG(_29$$20, 13);
zephir_array_update_string(&definition, SL("type"), &_29$$20, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("blob"), "phalcon/db/adapter/pdo/mysql.zep", 266)) {
ZEPHIR_INIT_NVAR(_30$$21);
ZVAL_LONG(_30$$21, 11);
zephir_array_update_string(&definition, SL("type"), &_30$$21, PH_COPY | PH_SEPARATE);
break;
}
ZEPHIR_INIT_NVAR(_31$$4);
ZVAL_LONG(_31$$4, 2);
zephir_array_update_string(&definition, SL("type"), &_31$$4, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("("), "phalcon/db/adapter/pdo/mysql.zep", 281)) {
ZEPHIR_INIT_NVAR(matches);
ZVAL_NULL(matches);
ZEPHIR_INIT_NVAR(_32$$22);
zephir_preg_match(_32$$22, sizePattern, columnType, matches, 0, 0 , 0 TSRMLS_CC);
if (zephir_is_true(_32$$22)) {
ZEPHIR_OBS_NVAR(matchOne);
if (zephir_array_isset_long_fetch(&matchOne, matches, 1, 0 TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_33$$24);
ZVAL_LONG(_33$$24, zephir_get_intval(matchOne));
zephir_array_update_string(&definition, SL("size"), &_33$$24, PH_COPY | PH_SEPARATE);
}
ZEPHIR_OBS_NVAR(matchTwo);
if (zephir_array_isset_long_fetch(&matchTwo, matches, 2, 0 TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_34$$25);
ZVAL_LONG(_34$$25, zephir_get_intval(matchTwo));
zephir_array_update_string(&definition, SL("scale"), &_34$$25, PH_COPY | PH_SEPARATE);
}
}
}
if (zephir_memnstr_str(columnType, SL("unsigned"), "phalcon/db/adapter/pdo/mysql.zep", 296)) {
zephir_array_update_string(&definition, SL("unsigned"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
}
if (Z_TYPE_P(oldColumn) == IS_NULL) {
zephir_array_update_string(&definition, SL("first"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
} else {
zephir_array_update_string(&definition, SL("after"), &oldColumn, PH_COPY | PH_SEPARATE);
}
zephir_array_fetch_long(&_35$$3, field, 3, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/mysql.zep", 312 TSRMLS_CC);
if (ZEPHIR_IS_STRING(_35$$3, "PRI")) {
zephir_array_update_string(&definition, SL("primary"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
}
zephir_array_fetch_long(&_36$$3, field, 2, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/mysql.zep", 319 TSRMLS_CC);
if (ZEPHIR_IS_STRING(_36$$3, "NO")) {
zephir_array_update_string(&definition, SL("notNull"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
}
zephir_array_fetch_long(&_37$$3, field, 5, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/mysql.zep", 326 TSRMLS_CC);
if (ZEPHIR_IS_STRING(_37$$3, "auto_increment")) {
zephir_array_update_string(&definition, SL("autoIncrement"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
}
ZEPHIR_OBS_NVAR(_38$$3);
zephir_array_fetch_long(&_38$$3, field, 4, PH_NOISY, "phalcon/db/adapter/pdo/mysql.zep", 333 TSRMLS_CC);
if (Z_TYPE_P(_38$$3) != IS_NULL) {
zephir_array_fetch_long(&_39$$32, field, 4, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/mysql.zep", 334 TSRMLS_CC);
zephir_array_update_string(&definition, SL("default"), &_39$$32, PH_COPY | PH_SEPARATE);
}
zephir_array_fetch_long(&columnName, field, 0, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/mysql.zep", 340 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_40$$3);
object_init_ex(_40$$3, phalcon_db_column_ce);
ZEPHIR_CALL_METHOD(NULL, _40$$3, "__construct", &_41, 142, columnName, definition);
zephir_check_call_status();
zephir_array_append(&columns, _40$$3, PH_SEPARATE, "phalcon/db/adapter/pdo/mysql.zep", 341);
ZEPHIR_CPY_WRT(oldColumn, columnName);
}
RETURN_CCTOR(columns);
}