/**
* Executes the validation
*
* @param string $value
* @param int $minimum
* @param int $maximum
* @return boolean
*/
PHP_METHOD(Phalcon_Validation_Validator_StringLength, valid){
zval *value, *minimum = NULL, *maximum = NULL;
zval *length = NULL, *valid = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 2, &value, &minimum, &maximum);
if (!minimum) {
minimum = &PHALCON_GLOBAL(z_null);
}
if (!maximum) {
maximum = &PHALCON_GLOBAL(z_null);
}
/* At least one of 'min' or 'max' must be set */
if (Z_TYPE_P(minimum) == IS_NULL && Z_TYPE_P(maximum) == IS_NULL) {
PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "A minimum or maximum must be set");
return;
}
/* Check if mbstring is available to calculate the correct length */
if (phalcon_function_exists_ex(SL("mb_strlen")) == SUCCESS) {
PHALCON_CALL_FUNCTION(&length, "mb_strlen", value);
} else {
convert_to_string(value);
PHALCON_INIT_VAR(length);
ZVAL_LONG(length, Z_STRLEN_P(value));
}
/* Maximum length */
if (Z_TYPE_P(maximum) != IS_NULL) {
PHALCON_INIT_NVAR(valid);
is_smaller_function(valid, maximum, length);
if (PHALCON_IS_TRUE(valid)) {
phalcon_update_property_str(getThis(), SL("_type"), SL("TooLong"));
RETURN_MM_FALSE;
}
}
/* Minimum length */
if (Z_TYPE_P(minimum) != IS_NULL) {
PHALCON_INIT_NVAR(valid);
is_smaller_function(valid, length, minimum);
if (PHALCON_IS_TRUE(valid)) {
phalcon_update_property_str(getThis(), SL("_type"), SL("TooShort"));
RETURN_MM_FALSE;
}
}
RETURN_MM_TRUE;
}
/**
* Gets row in a specific position of the resultset
*
* @param int $index
* @return Phalcon\Mvc\Model
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset, offsetGet){
zval *index = NULL, *count = NULL, *exists = NULL, *valid = NULL, *current = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &index) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(count);
PHALCON_CALL_METHOD(count, this_ptr, "count", PH_NO_CHECK);
PHALCON_INIT_VAR(exists);
is_smaller_function(exists, index, count TSRMLS_CC);
if (Z_TYPE_P(exists) == IS_BOOL && Z_BVAL_P(exists)) {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(this_ptr, "seek", index, PH_NO_CHECK);
PHALCON_INIT_VAR(valid);
PHALCON_CALL_METHOD(valid, this_ptr, "valid", PH_NO_CHECK);
if (Z_TYPE_P(valid) != IS_BOOL || (Z_TYPE_P(valid) == IS_BOOL && Z_BVAL_P(valid))) {
PHALCON_INIT_VAR(current);
PHALCON_CALL_METHOD(current, this_ptr, "current", PH_NO_CHECK);
RETURN_CCTOR(current);
} else {
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
}
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "The index does not exist in the cursor");
return;
}
/**
* Gets row in a specific position of the resultset
*
* @param int $index
* @return Phalcon_Model_Base
*/
PHP_METHOD(Phalcon_Model_Resultset, offsetGet){
zval *index = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &index) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD(r0, this_ptr, "count", PHALCON_NO_CHECK);
PHALCON_INIT_VAR(r1);
is_smaller_function(r1, index, r0 TSRMLS_CC);
if (zend_is_true(r1)) {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(this_ptr, "seek", index, PHALCON_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_CALL_METHOD(r2, this_ptr, "valid", PHALCON_NO_CHECK);
if (Z_TYPE_P(r2) != IS_BOOL || (Z_TYPE_P(r2) == IS_BOOL && Z_BVAL_P(r2))) {
PHALCON_ALLOC_ZVAL_MM(r3);
PHALCON_CALL_METHOD(r3, this_ptr, "current", PHALCON_NO_CHECK);
PHALCON_RETURN_DZVAL(r3);
} else {
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
}
PHALCON_THROW_EXCEPTION_STR(phalcon_model_exception_ce, "The index does not exist in the cursor");
return;
}
PHP_METHOD(Phalcon_Internal_TestParent, smp6){
zval *v0 = NULL, *v1 = NULL, *v2 = NULL, *v3 = NULL;
zval *t0 = NULL, *t1 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL;
zval *p0[] = { NULL, NULL };
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzzz", &v0, &v1, &v2, &v3) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 10);
PHALCON_INIT_VAR(r0);
is_smaller_function(r0, t0, v1 TSRMLS_CC);
if (zend_is_true(r0)) {
PHALCON_ALLOC_ZVAL_MM(r1);
mul_function(r1, v2, v3 TSRMLS_CC);
PHALCON_RETURN_CTOR(r1);
} else {
PHALCON_INIT_VAR(t1);
ZVAL_LONG(t1, 30);
PHALCON_INIT_VAR(r2);
is_smaller_function(r2, v2, t1 TSRMLS_CC);
if (zend_is_true(r2)) {
PHALCON_ALLOC_ZVAL_MM(r3);
mul_function(r3, v1, v3 TSRMLS_CC);
PHALCON_RETURN_CTOR(r3);
} else {
PHALCON_ALLOC_ZVAL_MM(r4);
Z_ADDREF_P(v1);
p0[0] = v1;
Z_ADDREF_P(v2);
p0[1] = v2;
PHALCON_CALL_METHOD_PARAMS(r4, v0, "mp7", 2, p0, PHALCON_CALL_DEFAULT);
Z_DELREF_P(p0[0]);
Z_DELREF_P(p0[1]);
PHALCON_RETURN_DZVAL(r4);
}
}
PHALCON_MM_RESTORE();
RETURN_NULL();
}
/**
* Checks whether offset exists in the resultset
*
* @param int $index
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset, offsetExists){
zval *index, *count = NULL;
phalcon_fetch_params(0, 1, 0, &index);
PHALCON_CALL_METHODW(&count, getThis(), "count");
is_smaller_function(return_value, index, count);
zval_ptr_dtor(count);
}
/**
* Changes internal pointer to a specific position in the resultset
*/
PHP_METHOD(Phalcon_Model_Resultset, seek){
zval *position = NULL, *rows = NULL, *i = NULL;
zval *r0 = NULL, *r1 = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &position) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_FUNC_PARAMS_1(r0, "intval", position, 0x020);
phalcon_update_property_zval(this_ptr, "_pointer", strlen("_pointer"), r0 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_type", sizeof("_type")-1, PHALCON_NOISY TSRMLS_CC);
if (zend_is_true(t0)) {
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_connection", sizeof("_connection")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, "_resultResource", sizeof("_resultResource")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(t1, "dataseek", position, t2, PHALCON_NO_CHECK);
} else {
PHALCON_ALLOC_ZVAL_MM(t3);
phalcon_read_property(&t3, this_ptr, "_rows", sizeof("_rows")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(rows, t3);
Z_SET_ISREF_P(rows);
PHALCON_CALL_FUNC_PARAMS_1_NORETURN("reset", rows, 0x055);
Z_UNSET_ISREF_P(rows);
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 0);
fs_fd08_0:
PHALCON_INIT_VAR(r1);
is_smaller_function(r1, i, position TSRMLS_CC);
if (!zend_is_true(r1)) {
goto fe_fd08_0;
}
Z_SET_ISREF_P(rows);
PHALCON_CALL_FUNC_PARAMS_1_NORETURN("next", rows, 0x059);
Z_UNSET_ISREF_P(rows);
PHALCON_SEPARATE(i);
increment_function(i);
goto fs_fd08_0;
fe_fd08_0:
if(0){}
}
PHALCON_MM_RESTORE();
}
/**
* Checks whether offset exists in the resultset
*
* @param int $index
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset, offsetExists){
zval *index, *count;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &index);
PHALCON_INIT_VAR(count);
phalcon_call_method(count, this_ptr, "count");
is_smaller_function(return_value, index, count TSRMLS_CC);
RETURN_MM();
}
/**
* Changes internal pointer to a specific position in the resultset
*
* @param int $position
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset, seek){
zval *position = NULL, *int_position = NULL, *type = NULL, *result = NULL, *rows = NULL;
zval *i = NULL;
zval *r0 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &position) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(int_position);
PHALCON_CALL_FUNC_PARAMS_1(int_position, "intval", position);
phalcon_update_property_zval(this_ptr, SL("_pointer"), int_position TSRMLS_CC);
PHALCON_INIT_VAR(type);
phalcon_read_property(&type, this_ptr, SL("_type"), PH_NOISY_CC);
if (zend_is_true(type)) {
PHALCON_INIT_VAR(result);
phalcon_read_property(&result, this_ptr, SL("_result"), PH_NOISY_CC);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(result, "dataseek", position, PH_NO_CHECK);
} else {
PHALCON_INIT_VAR(rows);
phalcon_read_property(&rows, this_ptr, SL("_rows"), PH_NOISY_CC);
Z_SET_ISREF_P(rows);
PHALCON_CALL_FUNC_PARAMS_1_NORETURN("reset", rows);
Z_UNSET_ISREF_P(rows);
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 0);
fs_ebc1_0:
PHALCON_INIT_VAR(r0);
is_smaller_function(r0, i, position TSRMLS_CC);
if (!zend_is_true(r0)) {
goto fe_ebc1_0;
}
Z_SET_ISREF_P(rows);
PHALCON_CALL_FUNC_PARAMS_1_NORETURN("next", rows);
Z_UNSET_ISREF_P(rows);
PHALCON_SEPARATE(i);
increment_function(i);
goto fs_ebc1_0;
fe_ebc1_0:
if(0){}
}
PHALCON_MM_RESTORE();
}
/**
* Checks whether the manager has an active transaction
*
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, has){
zval *zero, *number;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(zero);
ZVAL_LONG(zero, 0);
PHALCON_OBS_VAR(number);
phalcon_read_property_this(&number, this_ptr, SL("_number"), PH_NOISY_CC);
is_smaller_function(return_value, zero, number TSRMLS_CC);
RETURN_MM();
}
/**
* Gets row in a specific position of the resultset
*
* @param int $index
* @return Phalcon\Mvc\ModelInterface
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset, offsetGet){
zval *index, *count, *exists, *pointer, *current = NULL, *valid;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &index);
PHALCON_INIT_VAR(count);
phalcon_call_method(count, this_ptr, "count");
PHALCON_INIT_VAR(exists);
is_smaller_function(exists, index, count TSRMLS_CC);
if (PHALCON_IS_TRUE(exists)) {
/**
* Check if the last record returned is the current requested
*/
PHALCON_OBS_VAR(pointer);
phalcon_read_property_this(&pointer, this_ptr, SL("_pointer"), PH_NOISY_CC);
if (PHALCON_IS_EQUAL(pointer, index)) {
PHALCON_INIT_VAR(current);
phalcon_call_method(current, this_ptr, "current");
RETURN_CCTOR(current);
}
/**
* Move the cursor to the specific position
*/
phalcon_call_method_p1_noret(this_ptr, "seek", index);
/**
* Check if the last record returned is the requested
*/
PHALCON_INIT_VAR(valid);
phalcon_call_method(valid, this_ptr, "valid");
if (PHALCON_IS_NOT_FALSE(valid)) {
PHALCON_INIT_NVAR(current);
phalcon_call_method(current, this_ptr, "current");
RETURN_CCTOR(current);
}
RETURN_MM_FALSE;
}
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "The index does not exist in the cursor");
return;
}
/**
* Check if the component is currently caching the output content
*
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_View, isCaching){
zval *zero, *cache_level, *is_caching;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(zero);
ZVAL_LONG(zero, 0);
PHALCON_OBS_VAR(cache_level);
phalcon_read_property_this(&cache_level, this_ptr, SL("_cacheLevel"), PH_NOISY_CC);
PHALCON_INIT_VAR(is_caching);
is_smaller_function(is_caching, zero, cache_level TSRMLS_CC);
RETURN_NCTOR(is_caching);
}
/**
* Phalcon\Mvc\Model\Resultset\Simple constructor
*
* @param Phalcon\Mvc\Model $model
* @param Phalcon\Db\Result\Pdo $result
* @param Phalcon\Cache\Backend $cache
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, __construct){
zval *model = NULL, *result = NULL, *cache = NULL, *fetch_assoc = NULL, *limit = NULL;
zval *row_count = NULL, *big_resultset = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &model, &result, &cache) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!cache) {
PHALCON_ALLOC_ZVAL_MM(cache);
ZVAL_NULL(cache);
}
phalcon_update_property_zval(this_ptr, SL("_model"), model TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_result"), result TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_cache"), cache TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(result)) {
PHALCON_INIT_VAR(fetch_assoc);
ZVAL_LONG(fetch_assoc, 1);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(result, "setfetchmode", fetch_assoc, PH_NO_CHECK);
PHALCON_INIT_VAR(limit);
ZVAL_LONG(limit, 32);
PHALCON_INIT_VAR(row_count);
PHALCON_CALL_METHOD(row_count, result, "numrows", PH_NO_CHECK);
PHALCON_INIT_VAR(big_resultset);
is_smaller_function(big_resultset, limit, row_count TSRMLS_CC);
if (PHALCON_IS_TRUE(big_resultset)) {
phalcon_update_property_long(this_ptr, SL("_type"), 1 TSRMLS_CC);
} else {
phalcon_update_property_long(this_ptr, SL("_type"), 0 TSRMLS_CC);
}
phalcon_update_property_zval(this_ptr, SL("_count"), row_count TSRMLS_CC);
}
PHALCON_MM_RESTORE();
}
/**
* Checks whether offset exists in the resultset
*
* @param int $index
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset, offsetExists){
zval *index = NULL, *count = NULL, *exists = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &index) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(count);
PHALCON_CALL_METHOD(count, this_ptr, "count", PH_NO_CHECK);
PHALCON_INIT_VAR(exists);
is_smaller_function(exists, index, count TSRMLS_CC);
RETURN_NCTOR(exists);
}
/**
* Checks whether request include attached files
*
* @return boolean
*/
PHP_METHOD(Phalcon_Http_Request, hasFiles){
zval *files = NULL, *number_files = NULL, *has_files = NULL;
zval *g0 = NULL;
zval *t0 = NULL;
PHALCON_MM_GROW();
phalcon_get_global(&g0, SL("_FILES")+1 TSRMLS_CC);
PHALCON_CPY_WRT(files, g0);
PHALCON_INIT_VAR(number_files);
phalcon_fast_count(number_files, g0 TSRMLS_CC);
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 0);
PHALCON_INIT_VAR(has_files);
is_smaller_function(has_files, t0, number_files TSRMLS_CC);
RETURN_NCTOR(has_files);
}
/**
* Checks whether request include attached files
*
* @return boolean
*/
PHP_METHOD(Phalcon_Request, hasFiles){
zval *g0 = NULL;
zval *r0 = NULL, *r1 = NULL;
zval *t0 = NULL;
PHALCON_MM_GROW();
phalcon_get_global(&g0, "_FILES", sizeof("_FILES") TSRMLS_CC);
if (zend_is_true(g0)) {
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_fast_count(r0, g0 TSRMLS_CC);
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 0);
PHALCON_INIT_VAR(r1);
is_smaller_function(r1, t0, r0 TSRMLS_CC);
PHALCON_RETURN_NCTOR(r1);
}
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
/**
* Checks whether offset exists in the resultset
*
* @param int $index
* @return boolean
*/
PHP_METHOD(Phalcon_Model_Resultset, offsetExists){
zval *index = NULL;
zval *r0 = NULL, *r1 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &index) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD(r0, this_ptr, "count", PHALCON_NO_CHECK);
PHALCON_INIT_VAR(r1);
is_smaller_function(r1, index, r0 TSRMLS_CC);
if (zend_is_true(r1)) {
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
/**
* Builds a HTML tag
*
*<code>
* echo Phalcon\Tag::tagHtml($name, $parameters, $selfClose, $onlyStart, $eol);
*</code>
*
* @param string $tagName
* @param array $parameters
* @param boolean $selfClose
* @param boolean $onlyStart
* @param boolean $useEol
* @return string
*/
PHP_METHOD(Phalcon_Tag, tagHtml){
zval *tag_name, *parameters = NULL, *self_close = NULL, *only_start = NULL;
zval *use_eol = NULL, *params = NULL, *local_code, *value = NULL, *key = NULL;
zval *five, *doctype, *is_xhtml, *eol;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 4, &tag_name, ¶meters, &self_close, &only_start, &use_eol);
if (!parameters) {
PHALCON_INIT_VAR(parameters);
}
if (!self_close) {
PHALCON_INIT_VAR(self_close);
ZVAL_BOOL(self_close, 0);
}
if (!only_start) {
PHALCON_INIT_VAR(only_start);
ZVAL_BOOL(only_start, 0);
}
if (!use_eol) {
PHALCON_INIT_VAR(use_eol);
ZVAL_BOOL(use_eol, 0);
}
if (Z_TYPE_P(parameters) != IS_ARRAY) {
PHALCON_INIT_VAR(params);
array_init_size(params, 1);
phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_CPY_WRT(params, parameters);
}
PHALCON_INIT_VAR(local_code);
PHALCON_CONCAT_SV(local_code, "<", tag_name);
if (!phalcon_is_iterable(params, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(value);
if (Z_TYPE_P(key) != IS_LONG) {
PHALCON_SCONCAT_SVSVS(local_code, " ", key, "=\"", value, "\"");
}
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_VAR(five);
ZVAL_LONG(five, 5);
PHALCON_OBS_VAR(doctype);
phalcon_read_static_property(&doctype, SL("phalcon\\tag"), SL("_documentType") TSRMLS_CC);
/**
* Check if Doctype is XHTML
*/
PHALCON_INIT_VAR(is_xhtml);
is_smaller_function(is_xhtml, five, doctype TSRMLS_CC);
if (zend_is_true(is_xhtml)) {
if (zend_is_true(self_close)) {
phalcon_concat_self_str(&local_code, SL(" />") TSRMLS_CC);
} else {
phalcon_concat_self_str(&local_code, SL(">") TSRMLS_CC);
}
} else {
if (zend_is_true(only_start)) {
phalcon_concat_self_str(&local_code, SL(">") TSRMLS_CC);
} else {
PHALCON_SCONCAT_SVS(local_code, "></", tag_name, ">");
}
}
if (zend_is_true(use_eol)) {
PHALCON_INIT_VAR(eol);
ZVAL_STRING(eol, PHP_EOL, 1);
phalcon_concat_self(&local_code, eol TSRMLS_CC);
}
RETURN_CTOR(local_code);
}
/**
* Makes the work of autoload registered classes
*
* @param string $className
*/
PHP_METHOD(Phalcon_Loader, autoLoad){
zval *class_name = NULL, *directory = NULL, *preffix = NULL, *file_name = NULL;
zval *t0 = NULL, *t1 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL;
zval *c0 = NULL, *c1 = 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", &class_name) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_namespaces", sizeof("_namespaces")-1, PHALCON_NOISY TSRMLS_CC);
if (phalcon_valid_foreach(t0 TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(t0);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_0c08_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_0c08_0;
} else {
PHALCON_INIT_VAR(preffix);
PHALCON_GET_FOREACH_KEY(preffix, ah0, hp0);
}
PHALCON_INIT_VAR(directory);
ZVAL_ZVAL(directory, *hd, 1, 0);
PHALCON_INIT_VAR(r0);
PHALCON_CALL_FUNC_PARAMS_1(r0, "strlen", class_name, 0x001);
PHALCON_INIT_VAR(r1);
is_smaller_function(r1, preffix, r0 TSRMLS_CC);
if (zend_is_true(r1)) {
PHALCON_INIT_VAR(r2);
PHALCON_INIT_VAR(c0);
ZVAL_LONG(c0, 0);
PHALCON_INIT_VAR(r3);
PHALCON_CALL_FUNC_PARAMS_1(r3, "strlen", preffix, 0x001);
PHALCON_CALL_FUNC_PARAMS_3(r2, "substr", class_name, c0, r3, 0x002);
PHALCON_INIT_VAR(r4);
is_equal_function(r4, r2, preffix TSRMLS_CC);
if (zend_is_true(r4)) {
PHALCON_INIT_VAR(r5);
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, "", 1);
PHALCON_CALL_FUNC_PARAMS_3(r5, "str_replace", preffix, c1, class_name, 0x003);
PHALCON_CPY_WRT(file_name, r5);
PHALCON_INIT_VAR(r6);
concat_function(r6, directory, file_name TSRMLS_CC);
if (phalcon_file_exists(r6 TSRMLS_CC) == SUCCESS) {
if (phalcon_require(file_name TSRMLS_CC) == FAILURE) {
return;
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
}
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_0c08_0;
fee_0c08_0:
if(0){}
} else {
return;
}
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_directories", sizeof("_directories")-1, PHALCON_NOISY TSRMLS_CC);
if (phalcon_valid_foreach(t1 TSRMLS_CC)) {
ah1 = Z_ARRVAL_P(t1);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
fes_0c08_1:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_0c08_1;
}
PHALCON_INIT_VAR(directory);
ZVAL_ZVAL(directory, *hd, 1, 0);
PHALCON_INIT_VAR(r7);
concat_function(r7, directory, file_name TSRMLS_CC);
if (phalcon_file_exists(r7 TSRMLS_CC) == SUCCESS) {
if (phalcon_require(file_name TSRMLS_CC) == FAILURE) {
return;
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_0c08_1;
fee_0c08_1:
if(0){}
} else {
return;
}
PHALCON_MM_RESTORE();
}
/**
* Helper method to query records based on a relation definition
*
* @param array $relation
* @param string $method
* @param Phalcon\Mvc\Model $record
*/
PHP_METHOD(Phalcon_Mvc_Model_Manager, _getRelationRecords){
zval *relation = NULL, *method = NULL, *record = NULL, *conditions = NULL, *placeholders = NULL;
zval *field = NULL, *value = NULL, *referenced_field = NULL, *condition = NULL;
zval *i = NULL, *fields = NULL, *number_args = NULL, *function_arguments = NULL;
zval *key = NULL, *join_conditions = NULL, *find_params = NULL, *arguments = NULL;
zval *reference_table = NULL, *referenced_entity = NULL;
zval *call_object = NULL, *records = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL;
zval *c0 = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
zend_class_entry *ce0;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &relation, &method, &record) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(conditions);
array_init(conditions);
PHALCON_INIT_VAR(placeholders);
array_init(placeholders);
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch_string(&r0, relation, SL("fi"), PH_NOISY_CC);
if (Z_TYPE_P(r0) != IS_ARRAY) {
PHALCON_INIT_VAR(field);
phalcon_array_fetch_string(&field, relation, SL("fi"), PH_NOISY_CC);
PHALCON_INIT_VAR(value);
PHALCON_CALL_METHOD_PARAMS_1(value, record, "readattribute", field, PH_NO_CHECK);
PHALCON_INIT_VAR(referenced_field);
phalcon_array_fetch_string(&referenced_field, relation, SL("rf"), PH_NOISY_CC);
PHALCON_INIT_VAR(condition);
PHALCON_CONCAT_VS(condition, referenced_field, " = ?0");
phalcon_array_update_long(&conditions, 0, &condition, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&placeholders, value, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 0);
PHALCON_INIT_VAR(fields);
phalcon_array_fetch_string(&fields, relation, SL("fi"), PH_NOISY_CC);
if (!phalcon_valid_foreach(fields TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(fields);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_74b5_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_74b5_0;
}
PHALCON_INIT_VAR(field);
ZVAL_ZVAL(field, *hd, 1, 0);
PHALCON_INIT_VAR(value);
PHALCON_CALL_METHOD_PARAMS_1(value, record, "readattribute", field, PH_NO_CHECK);
PHALCON_INIT_VAR(r1);
phalcon_array_fetch_string(&r1, relation, SL("rf"), PH_NOISY_CC);
PHALCON_INIT_VAR(referenced_field);
phalcon_array_fetch(&referenced_field, r1, i, PH_NOISY_CC);
PHALCON_INIT_VAR(condition);
PHALCON_CONCAT_VSV(condition, referenced_field, " = ?", i);
phalcon_array_append(&conditions, condition, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&placeholders, value, PH_SEPARATE TSRMLS_CC);
PHALCON_SEPARATE(i);
increment_function(i);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_74b5_0;
fee_74b5_0:
if(0){}
}
PHALCON_INIT_VAR(number_args);
PHALCON_CALL_FUNC(number_args, "func_num_args");
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 4);
PHALCON_ALLOC_ZVAL_MM(r2);
is_smaller_function(r2, t0, number_args TSRMLS_CC);
if (zend_is_true(r2)) {
PHALCON_INIT_VAR(function_arguments);
PHALCON_CALL_FUNC(function_arguments, "func_get_args");
if (!phalcon_valid_foreach(function_arguments TSRMLS_CC)) {
return;
}
ah1 = Z_ARRVAL_P(function_arguments);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
fes_74b5_1:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_74b5_1;
}
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah1, hp1);
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
PHALCON_INIT_VAR(t1);
ZVAL_LONG(t1, 0);
PHALCON_INIT_VAR(r3);
is_equal_function(r3, key, t1 TSRMLS_CC);
PHALCON_INIT_VAR(t2);
ZVAL_STRING(t2, "conditions", 1);
PHALCON_INIT_VAR(r4);
is_equal_function(r4, key, t2 TSRMLS_CC);
PHALCON_INIT_VAR(r5);
ZVAL_BOOL(r5, zend_is_true(r3) || zend_is_true(r4));
if (zend_is_true(r5)) {
phalcon_array_append(&conditions, value, PH_SEPARATE TSRMLS_CC);
}
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_74b5_1;
fee_74b5_1:
if(0){}
}
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, " AND ", 1);
PHALCON_INIT_VAR(join_conditions);
phalcon_fast_join(join_conditions, c0, conditions TSRMLS_CC);
PHALCON_INIT_VAR(find_params);
array_init(find_params);
phalcon_array_append(&find_params, join_conditions, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&find_params, SL("bind"), &placeholders, PH_COPY | PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(arguments);
array_init(arguments);
phalcon_array_append(&arguments, find_params, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(reference_table);
phalcon_array_fetch_string(&reference_table, relation, SL("rt"), PH_NOISY_CC);
ce0 = phalcon_fetch_class(reference_table TSRMLS_CC);
PHALCON_INIT_VAR(referenced_entity);
object_init_ex(referenced_entity, ce0);
PHALCON_CALL_METHOD_NORETURN(referenced_entity, "__construct", PH_CHECK);
PHALCON_ALLOC_ZVAL_MM(r6);
PHALCON_CALL_METHOD(r6, record, "getconnectionservice", PH_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(referenced_entity, "setconnectionservice", r6, PH_NO_CHECK);
PHALCON_INIT_VAR(call_object);
array_init(call_object);
phalcon_array_append(&call_object, referenced_entity, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&call_object, method, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(records);
PHALCON_CALL_FUNC_PARAMS_2(records, "call_user_func_array", call_object, arguments);
RETURN_CCTOR(records);
}
/**
* Returns a slice of the resultset to show in the pagination
*
* @return stdClass
*/
PHP_METHOD(Phalcon_Paginator_Adapter_Model, getPaginate){
zval *v0 = NULL, *v1 = NULL, *v2 = NULL, *v3 = NULL, *v4 = NULL, *v5 = NULL, *v6 = NULL;
zval *v7 = NULL, *v8 = NULL, *v9 = NULL, *v10 = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL, *t6 = NULL;
zval *t7 = NULL, *t8 = NULL, *t9 = NULL, *t10 = NULL, *t11 = NULL, *t12 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL, *r13 = NULL;
zval *r14 = NULL, *r15 = NULL, *r16 = NULL, *r17 = NULL, *r18 = NULL, *r19 = NULL, *r20 = NULL;
zval *r21 = NULL, *r22 = NULL, *r23 = NULL, *r24 = NULL, *r25 = NULL, *r26 = NULL, *r27 = NULL;
zval *r28 = NULL;
zval *i0 = NULL, *i1 = NULL, *i2 = NULL;
zval *a0 = NULL;
zval *p2[] = { NULL }, *p3[] = { NULL }, *p4[] = { NULL }, *p5[] = { NULL };
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_limitRows", sizeof("_limitRows")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
PHALCON_CPY_WRT(v0, t0);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_config", sizeof("_config")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch_string(&r0, t1, "data", strlen("data"), PHALCON_NOISY_FETCH TSRMLS_CC);
PHALCON_CPY_WRT(v1, r0);
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, "_page", sizeof("_page")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
PHALCON_CPY_WRT(v2, t2);
if (Z_TYPE_P(v2) == IS_NULL) {
PHALCON_INIT_VAR(v2);
ZVAL_LONG(v2, 1);
}
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_FUNC_PARAMS_1(r1, "count", v1, 0x008);
PHALCON_CPY_WRT(v3, r1);
PHALCON_ALLOC_ZVAL_MM(i0);
object_init(i0);
PHALCON_CPY_WRT(v4, i0);
PHALCON_INIT_VAR(t3);
ZVAL_LONG(t3, 1);
PHALCON_ALLOC_ZVAL_MM(r2);
sub_function(r2, v2, t3 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r3);
mul_function(r3, v0, r2 TSRMLS_CC);
PHALCON_CPY_WRT(v5, r3);
PHALCON_ALLOC_ZVAL_MM(r4);
PHALCON_INIT_VAR(t4);
ZVAL_LONG(t4, 1);
PHALCON_ALLOC_ZVAL_MM(r5);
sub_function(r5, v3, t4 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r6);
div_function(r6, r5, v0 TSRMLS_CC);
Z_ADDREF_P(r6);
PHALCON_CALL_FUNC_PARAMS_1(r4, "ceil", r6, 0x00D);
Z_DELREF_P(r6);
PHALCON_CPY_WRT(v6, r4);
if (Z_TYPE_P(v1) != IS_OBJECT) {
PHALCON_ALLOC_ZVAL_MM(i1);
object_init_ex(i1, phalcon_paginator_exception_class_entry);
PHALCON_INIT_VAR(p2[0]);
ZVAL_STRING(p2[0], "Invalid data for paginator", 1);
PHALCON_CALL_METHOD_PARAMS_NORETURN(i1, "__construct", 1, p2, PHALCON_CALL_CHECK);
zend_throw_exception_object(i1 TSRMLS_CC);
Z_ADDREF_P(i1);
PHALCON_MM_RESTORE();
return;
}
if (Z_TYPE_P(v2) == IS_NULL) {
PHALCON_INIT_VAR(v2);
ZVAL_LONG(v2, 0);
}
PHALCON_INIT_VAR(t5);
ZVAL_LONG(t5, 0);
PHALCON_INIT_VAR(r7);
is_smaller_function(r7, v5, t5 TSRMLS_CC);
if (zend_is_true(r7)) {
PHALCON_ALLOC_ZVAL_MM(i2);
object_init_ex(i2, phalcon_paginator_exception_class_entry);
PHALCON_INIT_VAR(p3[0]);
ZVAL_STRING(p3[0], "The start page number is zero or less", 1);
PHALCON_CALL_METHOD_PARAMS_NORETURN(i2, "__construct", 1, p3, PHALCON_CALL_CHECK);
zend_throw_exception_object(i2 TSRMLS_CC);
Z_ADDREF_P(i2);
PHALCON_MM_RESTORE();
return;
}
PHALCON_INIT_VAR(a0);
array_init(a0);
phalcon_update_property_zval(v4, "items", strlen("items"), a0 TSRMLS_CC);
PHALCON_INIT_VAR(t6);
ZVAL_LONG(t6, 0);
PHALCON_INIT_VAR(r8);
is_smaller_function(r8, t6, v3 TSRMLS_CC);
if (zend_is_true(r8)) {
PHALCON_INIT_VAR(r9);
is_smaller_or_equal_function(r9, v5, v3 TSRMLS_CC);
if (zend_is_true(r9)) {
Z_ADDREF_P(v5);
p4[0] = v5;
PHALCON_CALL_METHOD_PARAMS_NORETURN(v1, "seek", 1, p4, PHALCON_CALL_DEFAULT);
Z_DELREF_P(p4[0]);
} else {
PHALCON_INIT_VAR(p5[0]);
ZVAL_LONG(p5[0], 1);
PHALCON_CALL_METHOD_PARAMS_NORETURN(v1, "seek", 1, p5, PHALCON_CALL_DEFAULT);
PHALCON_INIT_VAR(v2);
ZVAL_LONG(v2, 1);
}
PHALCON_INIT_VAR(v7);
ZVAL_LONG(v7, 1);
ws_e435_0:
PHALCON_INIT_VAR(r10);
PHALCON_CALL_METHOD(r10, v1, "valid", PHALCON_CALL_DEFAULT);
if (!zend_is_true(r10)) {
goto we_e435_0;
}
PHALCON_INIT_VAR(r11);
PHALCON_CALL_METHOD(r11, v1, "current", PHALCON_CALL_DEFAULT);
PHALCON_INIT_VAR(t7);
phalcon_read_property(&t7, v4, "items", sizeof("items")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
Z_ADDREF_P(r11);
phalcon_array_append(t7, r11 TSRMLS_CC);
phalcon_update_property_zval(v4, "items", strlen("items"), t7 TSRMLS_CC);
PHALCON_INIT_VAR(r12);
is_smaller_or_equal_function(r12, v0, v7 TSRMLS_CC);
if (zend_is_true(r12)) {
goto we_e435_0;
}
PHALCON_SEPARATE(v7);
increment_function(v7);
goto ws_e435_0;
we_e435_0:
if(0) { };
}
phalcon_update_property_long(v4, "first", strlen("first"), 1 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r13);
phalcon_add_function(r13, v5, v0 TSRMLS_CC);
PHALCON_INIT_VAR(r14);
is_smaller_function(r14, r13, v3 TSRMLS_CC);
if (zend_is_true(r14)) {
PHALCON_INIT_VAR(t8);
ZVAL_LONG(t8, 1);
PHALCON_ALLOC_ZVAL_MM(r15);
phalcon_add_function(r15, v2, t8 TSRMLS_CC);
PHALCON_CPY_WRT(v8, r15);
} else {
PHALCON_ALLOC_ZVAL_MM(r16);
phalcon_add_function(r16, v5, v0 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r17);
is_equal_function(r17, r16, v3 TSRMLS_CC);
if (zend_is_true(r17)) {
PHALCON_CPY_WRT(v8, v3);
} else {
PHALCON_ALLOC_ZVAL_MM(r18);
PHALCON_ALLOC_ZVAL_MM(r19);
div_function(r19, v3, v0 TSRMLS_CC);
PHALCON_CALL_FUNC_PARAMS_1(r18, "intval", r19, 0x00E);
PHALCON_INIT_VAR(t9);
ZVAL_LONG(t9, 1);
PHALCON_ALLOC_ZVAL_MM(r20);
phalcon_add_function(r20, r18, t9 TSRMLS_CC);
PHALCON_CPY_WRT(v8, r20);
}
}
PHALCON_INIT_VAR(r21);
is_smaller_function(r21, v6, v8 TSRMLS_CC);
if (zend_is_true(r21)) {
PHALCON_CPY_WRT(v8, v6);
}
phalcon_update_property_zval(v4, "next", strlen("next"), v8 TSRMLS_CC);
PHALCON_INIT_VAR(t10);
ZVAL_LONG(t10, 1);
PHALCON_INIT_VAR(r22);
is_smaller_function(r22, t10, v2 TSRMLS_CC);
if (zend_is_true(r22)) {
PHALCON_INIT_VAR(t11);
ZVAL_LONG(t11, 1);
PHALCON_ALLOC_ZVAL_MM(r23);
sub_function(r23, v2, t11 TSRMLS_CC);
PHALCON_CPY_WRT(v9, r23);
} else {
PHALCON_INIT_VAR(v9);
ZVAL_LONG(v9, 1);
}
phalcon_update_property_zval(v4, "before", strlen("before"), v9 TSRMLS_CC);
phalcon_update_property_zval(v4, "current", strlen("current"), v2 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r24);
mod_function(r24, v3, v0 TSRMLS_CC);
if (zend_is_true(r24)) {
PHALCON_ALLOC_ZVAL_MM(r25);
PHALCON_ALLOC_ZVAL_MM(r26);
div_function(r26, v3, v0 TSRMLS_CC);
PHALCON_CALL_FUNC_PARAMS_1(r25, "intval", r26, 0x00E);
PHALCON_INIT_VAR(t12);
ZVAL_LONG(t12, 1);
PHALCON_ALLOC_ZVAL_MM(r27);
phalcon_add_function(r27, r25, t12 TSRMLS_CC);
PHALCON_CPY_WRT(v10, r27);
} else {
PHALCON_ALLOC_ZVAL_MM(r28);
div_function(r28, v3, v0 TSRMLS_CC);
PHALCON_CPY_WRT(v10, r28);
}
phalcon_update_property_zval(v4, "last", strlen("last"), v10 TSRMLS_CC);
phalcon_update_property_zval(v4, "total_pages", strlen("total_pages"), v10 TSRMLS_CC);
PHALCON_RETURN_CTOR(v4);
}
/**
* Makes the work of autoload registered classes
*
* @param string $className
* @return boolean
*/
PHP_METHOD(Phalcon_Loader, autoLoad){
zval *class_name = NULL, *events_manager = NULL, *classes = NULL;
zval *file_path = NULL, *extensions = NULL, *namespaces = NULL, *ds = NULL;
zval *directory = NULL, *preffix = NULL, *file_name = NULL, *extension = NULL;
zval *path = NULL;
zval *c0 = NULL, *c1 = NULL, *c2 = NULL, *c3 = NULL, *c4 = NULL, *c5 = NULL, *c6 = NULL;
zval *c7 = NULL, *c8 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL;
zval *t0 = NULL;
HashTable *ah0, *ah1, *ah2, *ah3;
HashPosition hp0, hp1, hp2, hp3;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &class_name) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(events_manager);
phalcon_read_property(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
if (zend_is_true(events_manager)) {
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "loader:beforeCheckClass", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", c0, this_ptr, PH_NO_CHECK);
}
PHALCON_INIT_VAR(classes);
phalcon_read_property(&classes, this_ptr, SL("_classes"), PH_NOISY_CC);
eval_int = phalcon_array_isset(classes, class_name);
if (eval_int) {
PHALCON_INIT_VAR(file_path);
phalcon_array_fetch(&file_path, classes, class_name, PH_NOISY_CC);
if (zend_is_true(events_manager)) {
phalcon_update_property_zval(this_ptr, SL("_foundPath"), file_path TSRMLS_CC);
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, "loader:pathFound", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", c1, this_ptr, PH_NO_CHECK);
}
if (phalcon_require(file_path TSRMLS_CC) == FAILURE) {
return;
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
PHALCON_INIT_VAR(extensions);
phalcon_read_property(&extensions, this_ptr, SL("_extensions"), PH_NOISY_CC);
PHALCON_INIT_VAR(namespaces);
phalcon_read_property(&namespaces, this_ptr, SL("_namespaces"), PH_NOISY_CC);
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_fast_count(r0, namespaces TSRMLS_CC);
if (zend_is_true(r0)) {
PHALCON_INIT_VAR(ds);
zend_get_constant(SL("DIRECTORY_SEPARATOR"), ds TSRMLS_CC);
if (!phalcon_valid_foreach(namespaces TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(namespaces);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_0c08_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_0c08_0;
}
PHALCON_INIT_VAR(preffix);
PHALCON_GET_FOREACH_KEY(preffix, ah0, hp0);
PHALCON_INIT_VAR(directory);
ZVAL_ZVAL(directory, *hd, 1, 0);
PHALCON_INIT_VAR(r1);
PHALCON_CALL_FUNC_PARAMS_1(r1, "strlen", class_name);
PHALCON_INIT_VAR(r2);
PHALCON_CALL_FUNC_PARAMS_1(r2, "strlen", preffix);
PHALCON_INIT_VAR(r3);
is_smaller_function(r3, r2, r1 TSRMLS_CC);
if (zend_is_true(r3)) {
PHALCON_INIT_VAR(c2);
ZVAL_LONG(c2, 0);
PHALCON_INIT_VAR(r4);
PHALCON_CALL_FUNC_PARAMS_1(r4, "strlen", preffix);
PHALCON_INIT_VAR(r5);
PHALCON_CALL_FUNC_PARAMS_3(r5, "substr", class_name, c2, r4);
PHALCON_INIT_VAR(r6);
is_equal_function(r6, r5, preffix TSRMLS_CC);
if (zend_is_true(r6)) {
PHALCON_INIT_VAR(r7);
PHALCON_CONCAT_VS(r7, preffix, "\\");
PHALCON_INIT_VAR(c3);
ZVAL_STRING(c3, "", 1);
PHALCON_INIT_VAR(file_name);
phalcon_fast_str_replace(file_name, r7, c3, class_name TSRMLS_CC);
if (zend_is_true(file_name)) {
if (!phalcon_valid_foreach(extensions TSRMLS_CC)) {
return;
}
ah1 = Z_ARRVAL_P(extensions);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
fes_0c08_1:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_0c08_1;
}
PHALCON_INIT_VAR(extension);
ZVAL_ZVAL(extension, *hd, 1, 0);
PHALCON_INIT_VAR(c4);
ZVAL_STRING(c4, "\\", 1);
PHALCON_INIT_VAR(r8);
PHALCON_CONCAT_VVSV(r8, directory, file_name, ".", extension);
PHALCON_INIT_VAR(path);
phalcon_fast_str_replace(path, c4, ds, r8 TSRMLS_CC);
if (zend_is_true(events_manager)) {
phalcon_update_property_zval(this_ptr, SL("_checkedPath"), path TSRMLS_CC);
PHALCON_INIT_VAR(c5);
ZVAL_STRING(c5, "loader:beforeCheckPath", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", c5, this_ptr, PH_NO_CHECK);
}
if (phalcon_file_exists(path TSRMLS_CC) == SUCCESS) {
if (zend_is_true(events_manager)) {
phalcon_update_property_zval(this_ptr, SL("_foundPath"), file_path TSRMLS_CC);
PHALCON_INIT_VAR(c6);
ZVAL_STRING(c6, "loader:pathFound", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", c6, this_ptr, PH_NO_CHECK);
}
if (phalcon_require(path TSRMLS_CC) == FAILURE) {
return;
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_0c08_1;
fee_0c08_1:
if(0){}
}
}
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_0c08_0;
fee_0c08_0:
if(0){}
}
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_directories"), PH_NOISY_CC);
if (!phalcon_valid_foreach(t0 TSRMLS_CC)) {
return;
}
ah2 = Z_ARRVAL_P(t0);
zend_hash_internal_pointer_reset_ex(ah2, &hp2);
fes_0c08_2:
if(zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) != SUCCESS){
goto fee_0c08_2;
}
PHALCON_INIT_VAR(directory);
ZVAL_ZVAL(directory, *hd, 1, 0);
if (!phalcon_valid_foreach(extensions TSRMLS_CC)) {
return;
}
ah3 = Z_ARRVAL_P(extensions);
zend_hash_internal_pointer_reset_ex(ah3, &hp3);
fes_0c08_3:
if(zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) != SUCCESS){
goto fee_0c08_3;
}
PHALCON_INIT_VAR(extension);
ZVAL_ZVAL(extension, *hd, 1, 0);
PHALCON_INIT_VAR(path);
PHALCON_CONCAT_VVSV(path, directory, class_name, ".", extension);
if (zend_is_true(events_manager)) {
phalcon_update_property_zval(this_ptr, SL("_checkedPath"), path TSRMLS_CC);
PHALCON_INIT_VAR(c7);
ZVAL_STRING(c7, "loader:beforeCheckPath", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", c7, this_ptr, PH_NO_CHECK);
}
if (phalcon_file_exists(path TSRMLS_CC) == SUCCESS) {
if (phalcon_require(path TSRMLS_CC) == FAILURE) {
return;
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
zend_hash_move_forward_ex(ah3, &hp3);
goto fes_0c08_3;
fee_0c08_3:
if(0){}
zend_hash_move_forward_ex(ah2, &hp2);
goto fes_0c08_2;
fee_0c08_2:
if(0){}
if (zend_is_true(events_manager)) {
PHALCON_INIT_VAR(c8);
ZVAL_STRING(c8, "loader:afterCheckClass", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", c8, this_ptr, PH_NO_CHECK);
}
RETURN_CCTOR(this_ptr);
}
/**
* Executes the validator
*
* @return boolean
*/
PHP_METHOD(Phalcon_Model_Validator_Uniqueness, validate){
zval *record = NULL, *field = NULL, *conditions = NULL, *compose_field = NULL;
zval *value = NULL, *manager = NULL, *meta_data = NULL, *primary_fields = NULL;
zval *primary_field = NULL, *options = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL, *r13 = NULL;
zval *r14 = NULL, *r15 = NULL, *r16 = NULL, *r17 = NULL, *r18 = NULL, *r19 = NULL, *r20 = NULL;
zval *i0 = NULL;
zval *a0 = NULL;
zval *c0 = NULL, *c1 = NULL, *c2 = NULL;
zval *t0 = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
int eval_int;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD(r0, this_ptr, "isrequired", PHALCON_NO_CHECK);
if (zend_is_true(r0)) {
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_METHOD(r1, this_ptr, "getrecord", PHALCON_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(i0);
if (phalcon_clone(i0, r1 TSRMLS_CC) == FAILURE){
return;
}
PHALCON_CPY_WRT(record, i0);
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_CALL_METHOD(r2, this_ptr, "getfieldname", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(field, r2);
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(conditions, a0);
if (Z_TYPE_P(field) == IS_ARRAY) {
if (phalcon_valid_foreach(field TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(field);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_d73d_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_d73d_0;
}
PHALCON_INIT_VAR(compose_field);
ZVAL_ZVAL(compose_field, *hd, 1, 0);
PHALCON_INIT_VAR(r3);
PHALCON_INIT_VAR(r4);
PHALCON_CALL_METHOD_PARAMS_1(r4, record, "readattribute", compose_field, PHALCON_NO_CHECK);
PHALCON_CALL_FUNC_PARAMS_1(r3, "addslashes", r4, 0x00F);
PHALCON_CPY_WRT(value, r3);
PHALCON_INIT_VAR(r5);
PHALCON_CONCAT_VSVS(r5, compose_field, "='", value, "'");
phalcon_array_append(&conditions, r5, PHALCON_SEPARATE_PLZ TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_d73d_0;
fee_d73d_0:
if(0){}
} else {
return;
}
} else {
PHALCON_ALLOC_ZVAL_MM(r6);
PHALCON_ALLOC_ZVAL_MM(r7);
PHALCON_CALL_METHOD(r7, this_ptr, "getvalue", PHALCON_NO_CHECK);
PHALCON_CALL_FUNC_PARAMS_1(r6, "addslashes", r7, 0x00F);
PHALCON_CPY_WRT(value, r6);
PHALCON_ALLOC_ZVAL_MM(r8);
PHALCON_CONCAT_VSVS(r8, field, "='", value, "'");
phalcon_array_append(&conditions, r8, PHALCON_SEPARATE_PLZ TSRMLS_CC);
}
PHALCON_ALLOC_ZVAL_MM(r9);
PHALCON_CALL_METHOD(r9, record, "getmanager", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(manager, r9);
PHALCON_ALLOC_ZVAL_MM(r10);
PHALCON_CALL_METHOD(r10, manager, "getmetadata", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(meta_data, r10);
PHALCON_ALLOC_ZVAL_MM(r11);
PHALCON_CALL_METHOD_PARAMS_1(r11, meta_data, "getprimarykeyattributes", record, PHALCON_NO_CHECK);
PHALCON_CPY_WRT(primary_fields, r11);
if (phalcon_valid_foreach(primary_fields TSRMLS_CC)) {
ah1 = Z_ARRVAL_P(primary_fields);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
fes_d73d_1:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_d73d_1;
}
PHALCON_INIT_VAR(primary_field);
ZVAL_ZVAL(primary_field, *hd, 1, 0);
PHALCON_INIT_VAR(r12);
PHALCON_INIT_VAR(r13);
PHALCON_INIT_VAR(r14);
PHALCON_CALL_METHOD_PARAMS_1(r14, record, "readattribute", primary_field, PHALCON_NO_CHECK);
PHALCON_CALL_FUNC_PARAMS_1(r13, "addslashes", r14, 0x00F);
PHALCON_CONCAT_VSVS(r12, primary_field, "<>'", r13, "'");
phalcon_array_append(&conditions, r12, PHALCON_SEPARATE_PLZ TSRMLS_CC);
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_d73d_1;
fee_d73d_1:
if(0){}
} else {
return;
}
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, " AND ", 1);
PHALCON_ALLOC_ZVAL_MM(r15);
phalcon_fast_join(r15, c0, conditions TSRMLS_CC);
PHALCON_CPY_WRT(conditions, r15);
PHALCON_ALLOC_ZVAL_MM(r16);
PHALCON_CALL_STATIC_ZVAL_PARAMS_1(r16, record, "count", conditions);
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 0);
PHALCON_INIT_VAR(r17);
is_smaller_function(r17, t0, r16 TSRMLS_CC);
if (zend_is_true(r17)) {
PHALCON_ALLOC_ZVAL_MM(r18);
PHALCON_CALL_METHOD(r18, this_ptr, "getoptions", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(options, r18);
eval_int = phalcon_array_isset_string(options, "message", strlen("message")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r19);
phalcon_array_fetch_string(&r19, options, "message", strlen("message"), PHALCON_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, "unique", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "appendmessage", r19, field, c1, PHALCON_NO_CHECK);
} else {
PHALCON_ALLOC_ZVAL_MM(r20);
PHALCON_CONCAT_SVS(r20, "Value of field '", field, "' is already present in another record");
PHALCON_INIT_VAR(c2);
ZVAL_STRING(c2, "unique", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "appendmessage", r20, field, c2, PHALCON_NO_CHECK);
}
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
/**
* Returns a PHQL statement built based on the builder parameters
*
* @return string
*/
PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getPhql){
zval *dependency_injector = NULL, *models, *conditions = NULL;
zval *one, *number_models, *invalid_condition;
zval *model = NULL, *service_name, *meta_data, *model_instance;
zval *no_primary = NULL, *primary_keys, *first_primary_key;
zval *column_map = NULL, *attribute_field = NULL, *exception_message;
zval *primary_key_condition, *phql, *columns;
zval *selected_columns = NULL, *column = NULL, *alias = NULL, *aliased_column = NULL;
zval *joined_columns = NULL, *selected_column = NULL, *selected_models;
zval *selected_model = NULL, *joined_models, *joins;
zval *join = NULL, *join_model = NULL, *join_conditions = NULL, *join_alias = NULL;
zval *join_type = NULL, *group, *group_items, *group_item = NULL;
zval *escaped_item = NULL, *joined_items = NULL, *having, *order;
zval *order_items, *order_item = NULL, *limit, *number;
zval *offset = NULL;
HashTable *ah0, *ah1, *ah2, *ah3, *ah4, *ah5;
HashPosition hp0, hp1, hp2, hp3, hp4, hp5;
zval **hd;
zend_class_entry *ce0;
PHALCON_MM_GROW();
PHALCON_OBS_VAR(dependency_injector);
phalcon_read_property(&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");
phalcon_update_property_zval(this_ptr, SL("_dependencyInjector"), dependency_injector TSRMLS_CC);
}
PHALCON_OBS_VAR(models);
phalcon_read_property(&models, this_ptr, SL("_models"), PH_NOISY_CC);
if (Z_TYPE_P(models) == IS_ARRAY) {
if (!phalcon_fast_count_ev(models TSRMLS_CC)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "At least one model is required to build the query");
return;
}
} else {
if (!zend_is_true(models)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "At least one model is required to build the query");
return;
}
}
PHALCON_OBS_VAR(conditions);
phalcon_read_property(&conditions, this_ptr, SL("_conditions"), PH_NOISY_CC);
if (phalcon_is_numeric(conditions)) {
/**
* If the conditions is a single numeric field. We internally create a condition
* using the related primary key
*/
if (Z_TYPE_P(models) == IS_ARRAY) {
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
PHALCON_INIT_VAR(number_models);
phalcon_fast_count(number_models, models TSRMLS_CC);
PHALCON_INIT_VAR(invalid_condition);
is_smaller_function(invalid_condition, one, number_models TSRMLS_CC);
if (PHALCON_IS_TRUE(invalid_condition)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Cannot build the query. Invalid condition");
return;
}
PHALCON_OBS_VAR(model);
phalcon_array_fetch_long(&model, models, 0, PH_NOISY_CC);
} else {
PHALCON_CPY_WRT(model, models);
}
PHALCON_INIT_VAR(service_name);
ZVAL_STRING(service_name, "modelsMetadata", 1);
/**
* Get the models metadata service to obtain the column names, column map and
* primary key
*/
PHALCON_INIT_VAR(meta_data);
PHALCON_CALL_METHOD_PARAMS_1(meta_data, dependency_injector, "getshared", service_name);
ce0 = phalcon_fetch_class(model TSRMLS_CC);
PHALCON_INIT_VAR(model_instance);
object_init_ex(model_instance, ce0);
if (phalcon_has_constructor(model_instance TSRMLS_CC)) {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(model_instance, "__construct", dependency_injector);
}
PHALCON_INIT_VAR(no_primary);
ZVAL_BOOL(no_primary, 1);
PHALCON_INIT_VAR(primary_keys);
PHALCON_CALL_METHOD_PARAMS_1(primary_keys, meta_data, "getprimarykeyattributes", model_instance);
if (phalcon_fast_count_ev(primary_keys TSRMLS_CC)) {
if (phalcon_array_isset_long(primary_keys, 0)) {
PHALCON_OBS_VAR(first_primary_key);
phalcon_array_fetch_long(&first_primary_key, primary_keys, 0, PH_NOISY_CC);
/**
* The PHQL contains the renamed columns if available
*/
if (PHALCON_GLOBAL(orm).column_renaming) {
PHALCON_INIT_VAR(column_map);
PHALCON_CALL_METHOD_PARAMS_1(column_map, meta_data, "getcolumnmap", model_instance);
} else {
PHALCON_INIT_NVAR(column_map);
}
if (Z_TYPE_P(column_map) == IS_ARRAY) {
if (phalcon_array_isset(column_map, first_primary_key)) {
PHALCON_OBS_VAR(attribute_field);
phalcon_array_fetch(&attribute_field, column_map, first_primary_key, PH_NOISY_CC);
} else {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Column '", first_primary_key, "\" isn't part of the column map");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message);
return;
}
} else {
PHALCON_CPY_WRT(attribute_field, first_primary_key);
}
PHALCON_INIT_VAR(primary_key_condition);
PHALCON_CONCAT_SVSVSV(primary_key_condition, "[", model, "].[", attribute_field, "] = ", conditions);
PHALCON_CPY_WRT(conditions, primary_key_condition);
ZVAL_BOOL(no_primary, 0);
}
}
/**
* A primary key is mandatory in these cases
*/
if (PHALCON_IS_TRUE(no_primary)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Source related to this model does not have a primary key defined");
return;
}
}
PHALCON_INIT_VAR(phql);
ZVAL_STRING(phql, "SELECT ", 1);
PHALCON_OBS_VAR(columns);
phalcon_read_property(&columns, this_ptr, SL("_columns"), PH_NOISY_CC);
if (Z_TYPE_P(columns) != IS_NULL) {
if (Z_TYPE_P(columns) == IS_ARRAY) {
PHALCON_INIT_VAR(selected_columns);
array_init(selected_columns);
if (!phalcon_is_iterable(columns, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(alias, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(column);
if (Z_TYPE_P(alias) == IS_LONG) {
phalcon_array_append(&selected_columns, column, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_NVAR(aliased_column);
PHALCON_CONCAT_VSV(aliased_column, column, " AS ", alias);
phalcon_array_append(&selected_columns, aliased_column, PH_SEPARATE TSRMLS_CC);
}
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_VAR(joined_columns);
phalcon_fast_join_str(joined_columns, SL(", "), selected_columns TSRMLS_CC);
phalcon_concat_self(&phql, joined_columns TSRMLS_CC);
} else {
phalcon_concat_self(&phql, columns TSRMLS_CC);
}
} else {
if (Z_TYPE_P(models) == IS_ARRAY) {
PHALCON_INIT_NVAR(selected_columns);
array_init(selected_columns);
if (!phalcon_is_iterable(models, &ah1, &hp1, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(alias, ah1, hp1);
PHALCON_GET_FOREACH_VALUE(model);
if (Z_TYPE_P(alias) == IS_LONG) {
PHALCON_INIT_NVAR(selected_column);
PHALCON_CONCAT_SVS(selected_column, "[", model, "].*");
} else {
PHALCON_INIT_NVAR(selected_column);
PHALCON_CONCAT_SVS(selected_column, "[", alias, "].*");
}
phalcon_array_append(&selected_columns, selected_column, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah1, &hp1);
}
PHALCON_INIT_NVAR(joined_columns);
phalcon_fast_join_str(joined_columns, SL(", "), selected_columns TSRMLS_CC);
phalcon_concat_self(&phql, joined_columns TSRMLS_CC);
} else {
PHALCON_SCONCAT_SVS(phql, "[", models, "].*");
}
}
/**
* Join multiple models or use a single one if it is a string
*/
if (Z_TYPE_P(models) == IS_ARRAY) {
PHALCON_INIT_VAR(selected_models);
array_init(selected_models);
if (!phalcon_is_iterable(models, &ah2, &hp2, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(alias, ah2, hp2);
PHALCON_GET_FOREACH_VALUE(model);
if (Z_TYPE_P(alias) == IS_STRING) {
PHALCON_INIT_NVAR(selected_model);
PHALCON_CONCAT_SVSVS(selected_model, "[", model, "] AS [", alias, "]");
} else {
PHALCON_INIT_NVAR(selected_model);
PHALCON_CONCAT_SVS(selected_model, "[", model, "]");
}
phalcon_array_append(&selected_models, selected_model, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah2, &hp2);
}
PHALCON_INIT_VAR(joined_models);
phalcon_fast_join_str(joined_models, SL(", "), selected_models TSRMLS_CC);
PHALCON_SCONCAT_SV(phql, " FROM ", joined_models);
} else {
PHALCON_SCONCAT_SVS(phql, " FROM [", models, "]");
}
/**
* Check if joins were passed to the builders
*/
PHALCON_OBS_VAR(joins);
phalcon_read_property(&joins, this_ptr, SL("_joins"), PH_NOISY_CC);
if (Z_TYPE_P(joins) == IS_ARRAY) {
if (!phalcon_is_iterable(joins, &ah3, &hp3, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(join);
/**
* The joined table is in the first place of the array
*/
PHALCON_OBS_NVAR(join_model);
phalcon_array_fetch_long(&join_model, join, 0, PH_NOISY_CC);
/**
* The join conditions are in the second place of the array
*/
PHALCON_OBS_NVAR(join_conditions);
phalcon_array_fetch_long(&join_conditions, join, 1, PH_NOISY_CC);
/**
* The join alias is in the second place of the array
*/
PHALCON_OBS_NVAR(join_alias);
phalcon_array_fetch_long(&join_alias, join, 2, PH_NOISY_CC);
/**
* Join type
*/
PHALCON_OBS_NVAR(join_type);
phalcon_array_fetch_long(&join_type, join, 3, PH_NOISY_CC);
/**
* Create the join according to the type
*/
if (zend_is_true(join_type)) {
PHALCON_SCONCAT_VSVS(phql, join_type, " JOIN [", join_model, "]");
} else {
PHALCON_SCONCAT_SVS(phql, " JOIN [", join_model, "]");
}
/**
* Alias comes first
*/
if (zend_is_true(join_alias)) {
PHALCON_SCONCAT_SVS(phql, " AS [", join_alias, "]");
}
/**
* Conditions then
*/
if (zend_is_true(join_conditions)) {
PHALCON_SCONCAT_SV(phql, " ON ", join_conditions);
}
zend_hash_move_forward_ex(ah3, &hp3);
}
}
if (Z_TYPE_P(conditions) == IS_STRING) {
PHALCON_SCONCAT_SV(phql, " WHERE ", conditions);
}
/**
* Process group parameters
*/
PHALCON_OBS_VAR(group);
phalcon_read_property(&group, this_ptr, SL("_group"), PH_NOISY_CC);
if (Z_TYPE_P(group) != IS_NULL) {
if (Z_TYPE_P(group) == IS_ARRAY) {
PHALCON_INIT_VAR(group_items);
array_init(group_items);
if (!phalcon_is_iterable(group, &ah4, &hp4, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah4, (void**) &hd, &hp4) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(group_item);
if (phalcon_is_numeric(group_item)) {
phalcon_array_append(&group_items, group_item, PH_SEPARATE TSRMLS_CC);
} else {
if (phalcon_memnstr_str(group_item, SL(".") TSRMLS_CC)) {
phalcon_array_append(&group_items, group_item, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_NVAR(escaped_item);
PHALCON_CONCAT_SVS(escaped_item, "[", group_item, "]");
phalcon_array_append(&group_items, escaped_item, PH_SEPARATE TSRMLS_CC);
}
}
zend_hash_move_forward_ex(ah4, &hp4);
}
PHALCON_INIT_VAR(joined_items);
phalcon_fast_join_str(joined_items, SL(", "), group_items TSRMLS_CC);
PHALCON_SCONCAT_SV(phql, " GROUP BY ", joined_items);
} else {
if (phalcon_is_numeric(group)) {
PHALCON_SCONCAT_SV(phql, " GROUP BY ", group);
} else {
if (phalcon_memnstr_str(group, SL(".") TSRMLS_CC)) {
PHALCON_SCONCAT_SV(phql, " GROUP BY ", group);
} else {
PHALCON_SCONCAT_SVS(phql, " GROUP BY [", group, "]");
}
}
}
PHALCON_OBS_VAR(having);
phalcon_read_property(&having, this_ptr, SL("_having"), PH_NOISY_CC);
if (Z_TYPE_P(having) != IS_NULL) {
PHALCON_SCONCAT_SV(phql, " HAVING ", having);
}
}
/**
* Process order clause
*/
PHALCON_OBS_VAR(order);
phalcon_read_property(&order, this_ptr, SL("_order"), PH_NOISY_CC);
if (Z_TYPE_P(order) != IS_NULL) {
if (Z_TYPE_P(order) == IS_ARRAY) {
PHALCON_INIT_VAR(order_items);
array_init(order_items);
if (!phalcon_is_iterable(order, &ah5, &hp5, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah5, (void**) &hd, &hp5) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(order_item);
if (phalcon_is_numeric(order_item)) {
phalcon_array_append(&order_items, order_item, PH_SEPARATE TSRMLS_CC);
} else {
if (phalcon_memnstr_str(order_item, SL(".") TSRMLS_CC)) {
phalcon_array_append(&order_items, order_item, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_NVAR(escaped_item);
PHALCON_CONCAT_SVS(escaped_item, "[", order_item, "]");
phalcon_array_append(&order_items, escaped_item, PH_SEPARATE TSRMLS_CC);
}
}
zend_hash_move_forward_ex(ah5, &hp5);
}
PHALCON_INIT_NVAR(joined_items);
phalcon_fast_join_str(joined_items, SL(", "), order_items TSRMLS_CC);
PHALCON_SCONCAT_SV(phql, " ORDER BY ", joined_items);
} else {
PHALCON_SCONCAT_SV(phql, " ORDER BY ", order);
}
}
/**
* Process limit parameters
*/
PHALCON_OBS_VAR(limit);
phalcon_read_property(&limit, this_ptr, SL("_limit"), PH_NOISY_CC);
if (Z_TYPE_P(limit) != IS_NULL) {
if (Z_TYPE_P(limit) == IS_ARRAY) {
PHALCON_OBS_VAR(number);
phalcon_array_fetch_string(&number, limit, SL("number"), PH_NOISY_CC);
if (phalcon_array_isset_string(limit, SS("offset"))) {
PHALCON_OBS_VAR(offset);
phalcon_array_fetch_string(&offset, limit, SL("offset"), PH_NOISY_CC);
if (phalcon_is_numeric(offset)) {
PHALCON_SCONCAT_SVSV(phql, " LIMIT ", number, " OFFSET ", offset);
} else {
PHALCON_SCONCAT_SVS(phql, " LIMIT ", number, " OFFSET 0");
}
} else {
PHALCON_SCONCAT_SV(phql, " LIMIT ", number);
}
} else {
if (phalcon_is_numeric(limit)) {
PHALCON_SCONCAT_SV(phql, " LIMIT ", limit);
PHALCON_OBS_NVAR(offset);
phalcon_read_property(&offset, this_ptr, SL("_offset"), PH_NOISY_CC);
if (Z_TYPE_P(offset) != IS_NULL) {
if (phalcon_is_numeric(offset)) {
PHALCON_SCONCAT_SV(phql, " OFFSET ", offset);
} else {
phalcon_concat_self_str(&phql, SL(" OFFSET 0") TSRMLS_CC);
}
}
}
}
}
RETURN_CTOR(phql);
}
/**
* Returns a slice of the resultset to show in the pagination
*
* @return stdClass
*/
PHP_METHOD(Phalcon_Paginator_Adapter_Model, getPaginate){
zval *show = NULL, *config = NULL, *items = NULL, *page_number = NULL, *zero = NULL, *one = NULL;
zval *smaller = NULL, *n = NULL, *page = NULL, *last_show_page = NULL, *start = NULL;
zval *last_page = NULL, *possible_pages = NULL, *total_pages = NULL;
zval *compare = NULL, *page_items = NULL, *i = NULL, *valid = NULL, *current = NULL, *maximum_pages = NULL;
zval *next = NULL, *additional_page = NULL, *before = NULL, *remainder = NULL;
zval *pages_total = NULL;
zval *r0 = NULL;
zval *t0 = NULL;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(show);
phalcon_read_property(&show, this_ptr, SL("_limitRows"), PH_NOISY_CC);
PHALCON_INIT_VAR(config);
phalcon_read_property(&config, this_ptr, SL("_config"), PH_NOISY_CC);
PHALCON_INIT_VAR(items);
phalcon_array_fetch_string(&items, config, SL("data"), PH_NOISY_CC);
PHALCON_INIT_VAR(page_number);
phalcon_read_property(&page_number, this_ptr, SL("_page"), PH_NOISY_CC);
if (Z_TYPE_P(page_number) == IS_NULL) {
PHALCON_INIT_VAR(page_number);
ZVAL_LONG(page_number, 1);
}
PHALCON_INIT_VAR(zero);
ZVAL_LONG(zero, 0);
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
PHALCON_INIT_VAR(smaller);
is_smaller_function(smaller, show, zero TSRMLS_CC);
if (Z_TYPE_P(smaller) == IS_BOOL && Z_BVAL_P(smaller)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_paginator_exception_ce, "The start page number is zero or less");
return;
}
PHALCON_INIT_VAR(n);
phalcon_fast_count(n, items TSRMLS_CC);
PHALCON_INIT_VAR(page);
object_init(page);
PHALCON_INIT_VAR(last_show_page);
sub_function(last_show_page, page_number, one TSRMLS_CC);
PHALCON_INIT_VAR(start);
mul_function(start, show, last_show_page TSRMLS_CC);
PHALCON_INIT_VAR(last_page);
sub_function(last_page, n, one TSRMLS_CC);
PHALCON_INIT_VAR(possible_pages);
div_function(possible_pages, last_page, show TSRMLS_CC);
PHALCON_INIT_VAR(total_pages);
PHALCON_CALL_FUNC_PARAMS_1(total_pages, "ceil", possible_pages);
if (Z_TYPE_P(items) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_paginator_exception_ce, "Invalid data for paginator");
return;
}
if (Z_TYPE_P(page_number) == IS_NULL) {
PHALCON_INIT_VAR(page_number);
ZVAL_LONG(page_number, 0);
}
PHALCON_INIT_VAR(compare);
is_smaller_function(compare, start, zero TSRMLS_CC);
if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_paginator_exception_ce, "The start page number is zero or less");
return;
}
PHALCON_INIT_VAR(page_items);
array_init(page_items);
PHALCON_INIT_VAR(compare);
is_smaller_function(compare, zero, n TSRMLS_CC);
if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) {
PHALCON_INIT_VAR(compare);
is_smaller_or_equal_function(compare, start, n TSRMLS_CC);
if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(items, "seek", start, PH_NO_CHECK);
} else {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(items, "seek", one, PH_NO_CHECK);
PHALCON_INIT_VAR(page_number);
ZVAL_LONG(page_number, 1);
}
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 1);
ws_e435_0:
PHALCON_INIT_VAR(r0);
PHALCON_CALL_METHOD(r0, items, "valid", PH_NO_CHECK);
PHALCON_CPY_WRT(valid, r0);
if (Z_TYPE_P(valid) != IS_BOOL || (Z_TYPE_P(valid) == IS_BOOL && !Z_BVAL_P(valid))) {
goto we_e435_0;
}
PHALCON_INIT_VAR(current);
PHALCON_CALL_METHOD(current, items, "current", PH_NO_CHECK);
phalcon_array_append(&page_items, current, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(compare);
is_smaller_or_equal_function(compare, show, i TSRMLS_CC);
if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) {
goto we_e435_0;
}
PHALCON_SEPARATE(i);
increment_function(i);
goto ws_e435_0;
we_e435_0:
if(0){}
}
phalcon_update_property_zval(page, SL("items"), page_items TSRMLS_CC);
phalcon_update_property_long(page, SL("first"), 1 TSRMLS_CC);
PHALCON_INIT_VAR(maximum_pages);
phalcon_add_function(maximum_pages, start, show TSRMLS_CC);
PHALCON_INIT_VAR(compare);
is_smaller_function(compare, maximum_pages, n TSRMLS_CC);
if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) {
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 1);
PHALCON_INIT_VAR(next);
phalcon_add_function(next, page_number, t0 TSRMLS_CC);
} else {
PHALCON_INIT_VAR(compare);
is_equal_function(compare, maximum_pages, n TSRMLS_CC);
if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) {
PHALCON_CPY_WRT(next, n);
} else {
PHALCON_INIT_VAR(possible_pages);
div_function(possible_pages, n, show TSRMLS_CC);
PHALCON_INIT_VAR(additional_page);
phalcon_add_function(additional_page, possible_pages, one TSRMLS_CC);
PHALCON_INIT_VAR(next);
PHALCON_CALL_FUNC_PARAMS_1(next, "intval", additional_page);
}
}
PHALCON_INIT_VAR(compare);
is_smaller_function(compare, total_pages, next TSRMLS_CC);
if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) {
PHALCON_CPY_WRT(next, total_pages);
}
phalcon_update_property_zval(page, SL("next"), next TSRMLS_CC);
PHALCON_INIT_VAR(compare);
is_smaller_function(compare, one, page_number TSRMLS_CC);
if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) {
PHALCON_INIT_VAR(before);
sub_function(before, page_number, one TSRMLS_CC);
} else {
PHALCON_INIT_VAR(before);
ZVAL_LONG(before, 1);
}
phalcon_update_property_zval(page, SL("before"), before TSRMLS_CC);
phalcon_update_property_zval(page, SL("current"), page_number TSRMLS_CC);
PHALCON_INIT_VAR(remainder);
mod_function(remainder, n, show TSRMLS_CC);
PHALCON_INIT_VAR(possible_pages);
div_function(possible_pages, n, show TSRMLS_CC);
if (!phalcon_compare_strict_long(remainder, 0 TSRMLS_CC)) {
PHALCON_INIT_VAR(next);
phalcon_add_function(next, possible_pages, one TSRMLS_CC);
PHALCON_INIT_VAR(pages_total);
PHALCON_CALL_FUNC_PARAMS_1(pages_total, "intval", possible_pages);
} else {
PHALCON_CPY_WRT(pages_total, possible_pages);
}
phalcon_update_property_zval(page, SL("last"), pages_total TSRMLS_CC);
phalcon_update_property_zval(page, SL("total_pages"), pages_total TSRMLS_CC);
RETURN_CTOR(page);
}
/**
* Makes the work of autoload registered classes
*
* @param string $className
* @return boolean
*/
PHP_METHOD(Phalcon_Loader, autoLoad){
zval *class_name = NULL, *file_name = NULL, *directory = NULL, *preffix = NULL;
zval *path = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL;
zval *c0 = NULL, *c1 = NULL, *c2 = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &class_name) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_classes"), PHALCON_NOISY TSRMLS_CC);
eval_int = phalcon_array_isset(t0, class_name);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, SL("_classes"), PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch(&r0, t1, class_name, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(file_name, r0);
if (phalcon_require(file_name TSRMLS_CC) == FAILURE) {
return;
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, SL("_namespaces"), PHALCON_NOISY TSRMLS_CC);
if (phalcon_valid_foreach(t2 TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(t2);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_0c08_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_0c08_0;
} else {
PHALCON_INIT_VAR(preffix);
PHALCON_GET_FOREACH_KEY(preffix, ah0, hp0);
}
PHALCON_INIT_VAR(directory);
ZVAL_ZVAL(directory, *hd, 1, 0);
PHALCON_INIT_VAR(r1);
PHALCON_CALL_FUNC_PARAMS_1(r1, "strlen", class_name);
PHALCON_INIT_VAR(r2);
is_smaller_function(r2, preffix, r1 TSRMLS_CC);
if (zend_is_true(r2)) {
PHALCON_INIT_VAR(c0);
ZVAL_LONG(c0, 0);
PHALCON_INIT_VAR(r3);
PHALCON_CALL_FUNC_PARAMS_1(r3, "strlen", preffix);
PHALCON_INIT_VAR(r4);
PHALCON_CALL_FUNC_PARAMS_3(r4, "substr", class_name, c0, r3);
PHALCON_INIT_VAR(r5);
is_equal_function(r5, r4, preffix TSRMLS_CC);
if (zend_is_true(r5)) {
PHALCON_INIT_VAR(r6);
PHALCON_CONCAT_VS(r6, preffix, "\\");
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, "", 1);
PHALCON_INIT_VAR(r7);
phalcon_fast_str_replace(r7, r6, c1, class_name TSRMLS_CC);
PHALCON_CPY_WRT(file_name, r7);
if (zend_is_true(file_name)) {
PHALCON_INIT_VAR(c2);
ZVAL_STRING(c2, "\\", 1);
PHALCON_INIT_VAR(t3);
zend_get_constant("DIRECTORY_SEPARATOR", strlen("DIRECTORY_SEPARATOR"), t3 TSRMLS_CC);
PHALCON_INIT_VAR(r8);
PHALCON_CONCAT_VVS(r8, directory, file_name, ".php");
PHALCON_INIT_VAR(r9);
phalcon_fast_str_replace(r9, c2, t3, r8 TSRMLS_CC);
PHALCON_CPY_WRT(path, r9);
if (phalcon_file_exists(path TSRMLS_CC) == SUCCESS) {
if (phalcon_require(path TSRMLS_CC) == FAILURE) {
return;
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
}
}
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_0c08_0;
fee_0c08_0:
if(0){}
} else {
return;
}
PHALCON_ALLOC_ZVAL_MM(t4);
phalcon_read_property(&t4, this_ptr, SL("_directories"), PHALCON_NOISY TSRMLS_CC);
if (phalcon_valid_foreach(t4 TSRMLS_CC)) {
ah1 = Z_ARRVAL_P(t4);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
fes_0c08_1:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_0c08_1;
}
PHALCON_INIT_VAR(directory);
ZVAL_ZVAL(directory, *hd, 1, 0);
PHALCON_INIT_VAR(r10);
PHALCON_CONCAT_VVS(r10, directory, class_name, ".php");
PHALCON_CPY_WRT(path, r10);
if (phalcon_file_exists(path TSRMLS_CC) == SUCCESS) {
if (phalcon_require(path TSRMLS_CC) == FAILURE) {
return;
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_0c08_1;
fee_0c08_1:
if(0){}
} else {
return;
}
PHALCON_MM_RESTORE();
}
/**
* Builds HTML IMG tags
*
* <code>
* echo Phalcon\Tag::image("img/bg.png");
* echo Phalcon\Tag::image(array("img/photo.jpg", "alt" => "Some Photo"));
* </code>
*
* Volt Syntax:
* <code>
* {{ image("img/bg.png") }}
* {{ image("img/photo.jpg", "alt": "Some Photo") }}
* </code>
*
* @param array $parameters
* @return string
*/
PHP_METHOD(Phalcon_Tag, image){
zval *parameters = NULL, *params = NULL, *first_param, *url, *url_src;
zval *src, *code, *value = NULL, *key = NULL, *five, *doctype, *is_xhtml;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 1, ¶meters);
if (!parameters) {
PHALCON_INIT_VAR(parameters);
}
if (Z_TYPE_P(parameters) != IS_ARRAY) {
PHALCON_INIT_VAR(params);
array_init_size(params, 1);
phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_CPY_WRT(params, parameters);
}
if (!phalcon_array_isset_string(params, SS("src"))) {
if (phalcon_array_isset_long(params, 0)) {
PHALCON_OBS_VAR(first_param);
phalcon_array_fetch_long(&first_param, params, 0, PH_NOISY_CC);
phalcon_array_update_string(¶ms, SL("src"), &first_param, PH_COPY | PH_SEPARATE TSRMLS_CC);
} else {
phalcon_array_update_string_string(¶ms, SL("src"), SL(""), PH_SEPARATE TSRMLS_CC);
}
}
PHALCON_INIT_VAR(url);
PHALCON_CALL_SELF(url, this_ptr, "geturlservice");
PHALCON_OBS_VAR(url_src);
phalcon_array_fetch_string(&url_src, params, SL("src"), PH_NOISY_CC);
PHALCON_INIT_VAR(src);
PHALCON_CALL_METHOD_PARAMS_1(src, url, "get", url_src);
phalcon_array_update_string(¶ms, SL("src"), &src, PH_COPY | PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(code);
ZVAL_STRING(code, "<img", 1);
if (!phalcon_is_iterable(params, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(value);
if (Z_TYPE_P(key) != IS_LONG) {
PHALCON_SCONCAT_SVSVS(code, " ", key, "=\"", value, "\"");
}
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_VAR(five);
ZVAL_LONG(five, 5);
PHALCON_OBS_VAR(doctype);
phalcon_read_static_property(&doctype, SL("phalcon\\tag"), SL("_documentType") TSRMLS_CC);
/**
* Check if Doctype is XHTML
*/
PHALCON_INIT_VAR(is_xhtml);
is_smaller_function(is_xhtml, five, doctype TSRMLS_CC);
if (zend_is_true(is_xhtml)) {
phalcon_concat_self_str(&code, SL(" />") TSRMLS_CC);
} else {
phalcon_concat_self_str(&code, SL(">") TSRMLS_CC);
}
RETURN_CTOR(code);
}
/**
* Builds a LINK[rel="stylesheet"] tag
*
* <code>
* echo Phalcon\Tag::stylesheetLink("http://fonts.googleapis.com/css?family=Rosario", false);
* echo Phalcon\Tag::stylesheetLink("css/style.css");
* </code>
*
* Volt Syntax:
*<code>
* {{ stylesheet_link("http://fonts.googleapis.com/css?family=Rosario", false) }}
* {{ stylesheet_link("css/style.css") }}
*</code>
*
* @param array $parameters
* @param boolean $local
* @return string
*/
PHP_METHOD(Phalcon_Tag, stylesheetLink){
zval *parameters = NULL, *local = NULL, *params = NULL, *first_param;
zval *url, *url_href, *href, *code, *value = NULL, *key = NULL, *five;
zval *doctype, *eol, *is_xhtml;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 2, ¶meters, &local);
if (!parameters) {
PHALCON_INIT_VAR(parameters);
}
if (!local) {
PHALCON_INIT_VAR(local);
ZVAL_BOOL(local, 1);
} else {
PHALCON_SEPARATE_PARAM(local);
}
if (Z_TYPE_P(parameters) != IS_ARRAY) {
PHALCON_INIT_VAR(params);
array_init_size(params, 2);
phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(¶ms, local, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_CPY_WRT(params, parameters);
}
if (!phalcon_array_isset_string(params, SS("href"))) {
if (phalcon_array_isset_long(params, 0)) {
PHALCON_OBS_VAR(first_param);
phalcon_array_fetch_long(&first_param, params, 0, PH_NOISY_CC);
phalcon_array_update_string(¶ms, SL("href"), &first_param, PH_COPY | PH_SEPARATE TSRMLS_CC);
} else {
phalcon_array_update_string_string(¶ms, SL("href"), SL(""), PH_SEPARATE TSRMLS_CC);
}
}
PHALCON_INIT_NVAR(local);
ZVAL_STRING(local, "", 1);
if (phalcon_array_isset_long(params, 1)) {
PHALCON_OBS_NVAR(local);
phalcon_array_fetch_long(&local, params, 1, PH_NOISY_CC);
} else {
if (phalcon_array_isset_string(params, SS("local"))) {
PHALCON_OBS_NVAR(local);
phalcon_array_fetch_string(&local, params, SL("local"), PH_NOISY_CC);
phalcon_array_unset_string(¶ms, SS("local"), PH_SEPARATE);
}
}
if (!phalcon_array_isset_string(params, SS("type"))) {
phalcon_array_update_string_string(¶ms, SL("type"), SL("text/css"), PH_SEPARATE TSRMLS_CC);
}
if (zend_is_true(local)) {
PHALCON_INIT_VAR(url);
PHALCON_CALL_SELF(url, this_ptr, "geturlservice");
PHALCON_OBS_VAR(url_href);
phalcon_array_fetch_string(&url_href, params, SL("href"), PH_NOISY_CC);
PHALCON_INIT_VAR(href);
PHALCON_CALL_METHOD_PARAMS_1(href, url, "get", url_href);
phalcon_array_update_string(¶ms, SL("href"), &href, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(code);
ZVAL_STRING(code, "<link rel=\"stylesheet\"", 1);
if (!phalcon_is_iterable(params, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(value);
if (Z_TYPE_P(key) != IS_LONG) {
PHALCON_SCONCAT_SVSVS(code, " ", key, "=\"", value, "\"");
}
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_VAR(five);
ZVAL_LONG(five, 5);
PHALCON_OBS_VAR(doctype);
phalcon_read_static_property(&doctype, SL("phalcon\\tag"), SL("_documentType") TSRMLS_CC);
PHALCON_INIT_VAR(eol);
ZVAL_STRING(eol, PHP_EOL, 1);
/**
* Check if Doctype is XHTML
*/
PHALCON_INIT_VAR(is_xhtml);
is_smaller_function(is_xhtml, five, doctype TSRMLS_CC);
if (zend_is_true(is_xhtml)) {
PHALCON_SCONCAT_SV(code, " />", eol);
} else {
PHALCON_SCONCAT_SV(code, ">", eol);
}
RETURN_CTOR(code);
}
/**
* Dispatches a controller action taking into account the routing parameters
*
* @param Phalcon_Request $request
* @param Phalcon_Response $response
* @param Phalcon_View $view
* @param Phalcon_Model_Manager $model
* @return Phalcon_Controller
*/
PHP_METHOD(Phalcon_Dispatcher, dispatch){
zval *request = NULL, *response = NULL, *view = NULL, *model = NULL, *controllers_dir = NULL;
zval *value = NULL, *controller = NULL, *number_dispatches = NULL;
zval *controller_name = NULL, *controllers = NULL, *controller_class = NULL;
zval *controller_path = NULL, *params = NULL, *action_name = NULL;
zval *action_method = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL, *t6 = NULL;
zval *t7 = NULL, *t8 = NULL, *t9 = NULL, *t10 = NULL;
zval *c0 = NULL, *c1 = NULL, *c2 = NULL;
zval *i0 = NULL;
zval *a0 = NULL, *a1 = NULL;
zval *p0[] = { NULL, NULL, NULL, NULL, NULL };
int eval_int;
zend_class_entry *ce0;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|zz", &request, &response, &view, &model) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!view) {
PHALCON_INIT_VAR(view);
ZVAL_NULL(view);
}
if (!model) {
PHALCON_INIT_VAR(model);
ZVAL_NULL(model);
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_basePath"), PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, SL("_controllersDir"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CONCAT_VV(r0, t0, t1);
PHALCON_CPY_WRT(controllers_dir, r0);
PHALCON_INIT_VAR(value);
ZVAL_NULL(value);
PHALCON_INIT_VAR(controller);
ZVAL_NULL(controller);
PHALCON_INIT_VAR(number_dispatches);
ZVAL_LONG(number_dispatches, 0);
phalcon_update_property_bool(this_ptr, SL("_finished"), 0 TSRMLS_CC);
ws_e10f_0:
PHALCON_INIT_VAR(t2);
phalcon_read_property(&t2, this_ptr, SL("_finished"), PHALCON_NOISY TSRMLS_CC);
if (zend_is_true(t2)) {
goto we_e10f_0;
}
phalcon_update_property_bool(this_ptr, SL("_finished"), 1 TSRMLS_CC);
PHALCON_INIT_VAR(t3);
phalcon_read_property(&t3, this_ptr, SL("_controllerName"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(controller_name, t3);
if (!zend_is_true(controller_name)) {
PHALCON_INIT_VAR(t4);
phalcon_read_property(&t4, this_ptr, SL("_defaultController"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(controller_name, t4);
phalcon_update_property_zval(this_ptr, SL("_controllerName"), controller_name TSRMLS_CC);
}
PHALCON_INIT_VAR(t5);
phalcon_read_property(&t5, this_ptr, SL("_controllers"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(controllers, t5);
PHALCON_INIT_VAR(r1);
PHALCON_INIT_VAR(r2);
PHALCON_CALL_STATIC_PARAMS_1(r2, "phalcon_text", "camelize", controller_name);
PHALCON_CONCAT_VS(r1, r2, "Controller");
PHALCON_CPY_WRT(controller_class, r1);
eval_int = phalcon_array_isset(controllers, controller_class);
if (!eval_int) {
PHALCON_INIT_VAR(c0);
ZVAL_BOOL(c0, 0);
PHALCON_INIT_VAR(r3);
PHALCON_CALL_FUNC_PARAMS_2(r3, "class_exists", controller_class, c0);
if (!zend_is_true(r3)) {
PHALCON_INIT_VAR(r4);
PHALCON_CONCAT_VVS(r4, controllers_dir, controller_class, ".php");
PHALCON_CPY_WRT(controller_path, r4);
if (phalcon_file_exists(controller_path TSRMLS_CC) == SUCCESS) {
if (phalcon_require(controller_path TSRMLS_CC) == FAILURE) {
return;
}
} else {
PHALCON_INIT_VAR(r5);
PHALCON_CONCAT_SVS(r5, "File for controller class ", controller_class, " doesn't exist");
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "_throwdispatchexception", response, r5, PHALCON_NO_CHECK);
}
PHALCON_INIT_VAR(c1);
ZVAL_BOOL(c1, 0);
PHALCON_INIT_VAR(r6);
PHALCON_CALL_FUNC_PARAMS_2(r6, "class_exists", controller_class, c1);
if (!zend_is_true(r6)) {
PHALCON_INIT_VAR(r7);
PHALCON_CONCAT_SVS(r7, "Class ", controller_class, " was not found on controller file");
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "_throwdispatchexception", response, r7, PHALCON_NO_CHECK);
}
}
ce0 = phalcon_fetch_class(controller_class TSRMLS_CC);
PHALCON_INIT_VAR(i0);
object_init_ex(i0, ce0);
p0[0] = this_ptr;
p0[1] = request;
p0[2] = response;
p0[3] = view;
p0[4] = model;
PHALCON_CALL_METHOD_PARAMS_NORETURN(i0, "__construct", 5, p0, PHALCON_CHECK);
PHALCON_CPY_WRT(controller, i0);
if (phalcon_method_exists_ex(controller, SL("initialize") TSRMLS_CC) == SUCCESS) {
PHALCON_CALL_METHOD_NORETURN(controller, "initialize", PHALCON_NO_CHECK);
}
PHALCON_INIT_VAR(t6);
phalcon_read_property(&t6, this_ptr, SL("_controllers"), PHALCON_NOISY TSRMLS_CC);
phalcon_array_update(&t6, controller_class, &controller, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_controllers"), t6 TSRMLS_CC);
} else {
PHALCON_INIT_VAR(r8);
phalcon_array_fetch(&r8, controllers, controller_class, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(controller, r8);
}
PHALCON_INIT_VAR(t7);
phalcon_read_property(&t7, this_ptr, SL("_params"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(params, t7);
PHALCON_INIT_VAR(t8);
phalcon_read_property(&t8, this_ptr, SL("_actionName"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(action_name, t8);
if (!zend_is_true(action_name)) {
PHALCON_INIT_VAR(t9);
phalcon_read_property(&t9, this_ptr, SL("_defaultAction"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(action_name, t9);
phalcon_update_property_zval(this_ptr, SL("_actionName"), action_name TSRMLS_CC);
}
if (phalcon_method_exists_ex(controller, SL("beforedispatch") TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_VAR(r9);
PHALCON_CALL_METHOD_PARAMS_3(r9, controller, "beforedispatch", controller_name, action_name, params, PHALCON_NO_CHECK);
if (Z_TYPE_P(r9) == IS_BOOL && !Z_BVAL_P(r9)) {
PHALCON_INIT_VAR(value);
ZVAL_BOOL(value, 0);
goto we_e10f_0;
}
}
PHALCON_INIT_VAR(r10);
PHALCON_CONCAT_VS(r10, action_name, "Action");
PHALCON_CPY_WRT(action_method, r10);
if (phalcon_method_exists(controller, action_method TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_VAR(a0);
array_init(a0);
phalcon_array_append(&a0, controller, PHALCON_SEPARATE_PLZ TSRMLS_CC);
phalcon_array_append(&a0, action_method, PHALCON_SEPARATE_PLZ TSRMLS_CC);
PHALCON_INIT_VAR(value);
PHALCON_CALL_FUNC_PARAMS_2(value, "call_user_func_array", a0, params);
} else {
if (phalcon_method_exists_ex(controller, SL("notfoundaction") TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_VAR(a1);
array_init(a1);
phalcon_array_append(&a1, controller, PHALCON_SEPARATE_PLZ TSRMLS_CC);
add_next_index_stringl(a1, SL("notFoundAction"), 1);
PHALCON_INIT_VAR(value);
PHALCON_CALL_FUNC_PARAMS_2(value, "call_user_func_array", a1, params);
} else {
PHALCON_INIT_VAR(r11);
PHALCON_CONCAT_SVSVS(r11, "Action '", action_name, "' was not found on controller '", controller_name, "'");
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "_throwdispatchexception", response, r11, PHALCON_NO_CHECK);
}
}
if (phalcon_method_exists_ex(controller, SL("afterdispatch") TSRMLS_CC) == SUCCESS) {
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(controller, "afterdispatch", controller_name, action_name, params, PHALCON_NO_CHECK);
}
PHALCON_SEPARATE(number_dispatches);
increment_function(number_dispatches);
PHALCON_INIT_VAR(t10);
ZVAL_LONG(t10, 256);
PHALCON_INIT_VAR(r12);
is_smaller_function(r12, t10, number_dispatches TSRMLS_CC);
if (zend_is_true(r12)) {
PHALCON_INIT_VAR(c2);
ZVAL_STRING(c2, "Dispatcher has detected a cyclic routing causing stability problems", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "_throwdispatchexception", response, c2, PHALCON_NO_CHECK);
}
goto ws_e10f_0;
we_e10f_0:
phalcon_update_property_zval(this_ptr, SL("_returnedValue"), value TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_lastController"), controller TSRMLS_CC);
RETURN_CHECK_CTOR(controller);
}
/**
* Returns a cached content
*
* @param int|string $keyName
* @param long $lifetime
* @return mixed
*/
PHP_METHOD(Phalcon_Cache_Backend_File, get){
zval *key_name, *lifetime = NULL, *options, *prefix, *filtered;
zval *prefixed_key, *cache_dir, *cache_file;
zval *frontend, *time, *ttl = NULL, *modified_time, *difference;
zval *not_expired, *cached_content, *processed;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &key_name, &lifetime) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!lifetime) {
PHALCON_INIT_NVAR(lifetime);
}
PHALCON_INIT_VAR(options);
phalcon_read_property(&options, this_ptr, SL("_options"), PH_NOISY_CC);
PHALCON_INIT_VAR(prefix);
phalcon_read_property(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC);
PHALCON_INIT_VAR(filtered);
phalcon_filter_alphanum(filtered, key_name);
PHALCON_INIT_VAR(prefixed_key);
PHALCON_CONCAT_VV(prefixed_key, prefix, filtered);
phalcon_update_property_zval(this_ptr, SL("_lastKey"), prefixed_key TSRMLS_CC);
PHALCON_INIT_VAR(cache_dir);
phalcon_array_fetch_string(&cache_dir, options, SL("cacheDir"), PH_NOISY_CC);
PHALCON_INIT_VAR(cache_file);
PHALCON_CONCAT_VV(cache_file, cache_dir, prefixed_key);
if (phalcon_file_exists(cache_file TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_VAR(frontend);
phalcon_read_property(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC);
/**
* Check if the file has expired
*/
PHALCON_INIT_VAR(time);
PHALCON_CALL_FUNC(time, "time");
if (Z_TYPE_P(lifetime) == IS_NULL) {
PHALCON_INIT_VAR(ttl);
PHALCON_CALL_METHOD(ttl, frontend, "getlifetime", PH_NO_CHECK);
} else {
PHALCON_CPY_WRT(ttl, lifetime);
}
PHALCON_INIT_VAR(modified_time);
PHALCON_CALL_FUNC_PARAMS_1(modified_time, "filemtime", cache_file);
PHALCON_INIT_VAR(difference);
sub_function(difference, time, ttl TSRMLS_CC);
PHALCON_INIT_VAR(not_expired);
is_smaller_function(not_expired, difference, modified_time TSRMLS_CC);
/**
* The content is only retrieved if the content has not expired
*/
if (PHALCON_IS_TRUE(not_expired)) {
PHALCON_INIT_VAR(cached_content);
PHALCON_CALL_FUNC_PARAMS_1(cached_content, "file_get_contents", cache_file);
PHALCON_INIT_VAR(processed);
PHALCON_CALL_METHOD_PARAMS_1(processed, frontend, "afterretrieve", cached_content, PH_NO_CHECK);
RETURN_CCTOR(processed);
}
}
PHALCON_MM_RESTORE();
RETURN_NULL();
}
/**
* Builds generic INPUT tags
*
* @param string $type
* @param array $parameters
* @param boolean $asValue
* @return string
*/
PHP_METHOD(Phalcon_Tag, _inputField){
zval *type, *parameters, *as_value = NULL, *params = NULL, *value = NULL;
zval *id = NULL, *name, *code, *key = NULL, *five, *doctype, *is_xhtml;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 1, &type, ¶meters, &as_value);
if (!as_value) {
PHALCON_INIT_VAR(as_value);
ZVAL_BOOL(as_value, 0);
}
if (Z_TYPE_P(parameters) != IS_ARRAY) {
PHALCON_INIT_VAR(params);
array_init_size(params, 1);
phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_CPY_WRT(params, parameters);
}
PHALCON_INIT_VAR(value);
if (PHALCON_IS_FALSE(as_value)) {
if (!phalcon_array_isset_long(params, 0)) {
PHALCON_OBS_VAR(id);
phalcon_array_fetch_string(&id, params, SL("id"), PH_NOISY_CC);
phalcon_array_update_long(¶ms, 0, &id, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
PHALCON_OBS_NVAR(id);
phalcon_array_fetch_long(&id, params, 0, PH_NOISY_CC);
if (!phalcon_array_isset_string(params, SS("name"))) {
phalcon_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_OBS_VAR(name);
phalcon_array_fetch_string(&name, params, SL("name"), PH_NOISY_CC);
if (!zend_is_true(name)) {
phalcon_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
}
/**
* Automatically assign the id if the name is not an array
*/
if (!phalcon_memnstr_str(id, SL("[") TSRMLS_CC)) {
if (!phalcon_array_isset_string(params, SS("id"))) {
phalcon_array_update_string(¶ms, SL("id"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
}
if (!phalcon_array_isset_string(params, SS("value"))) {
PHALCON_CALL_SELF_PARAMS_2(value, this_ptr, "getvalue", id, params);
phalcon_array_update_string(¶ms, SL("value"), &value, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
} else {
if (phalcon_array_isset_long(params, 0)) {
PHALCON_OBS_NVAR(value);
phalcon_array_fetch_long(&value, params, 0, PH_NOISY_CC);
phalcon_array_update_string(¶ms, SL("value"), &value, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
}
/**
* Automatically check inputs
*/
if (PHALCON_IS_STRING(type, "checkbox")) {
if (zend_is_true(value)) {
phalcon_array_update_string_string(¶ms, SL("checked"), SL("checked"), PH_SEPARATE TSRMLS_CC);
}
} else {
if (PHALCON_IS_STRING(type, "radio")) {
if (zend_is_true(value)) {
phalcon_array_update_string_string(¶ms, SL("checked"), SL("checked"), PH_SEPARATE TSRMLS_CC);
}
}
}
PHALCON_INIT_VAR(code);
PHALCON_CONCAT_SVS(code, "<input type=\"", type, "\"");
if (!phalcon_is_iterable(params, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(value);
if (Z_TYPE_P(key) != IS_LONG) {
PHALCON_SCONCAT_SVSVS(code, " ", key, "=\"", value, "\"");
}
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_VAR(five);
ZVAL_LONG(five, 5);
PHALCON_OBS_VAR(doctype);
phalcon_read_static_property(&doctype, SL("phalcon\\tag"), SL("_documentType") TSRMLS_CC);
/**
* Check if Doctype is XHTML
*/
PHALCON_INIT_VAR(is_xhtml);
is_smaller_function(is_xhtml, five, doctype TSRMLS_CC);
if (zend_is_true(is_xhtml)) {
phalcon_concat_self_str(&code, SL(" />") TSRMLS_CC);
} else {
phalcon_concat_self_str(&code, SL(">") TSRMLS_CC);
}
RETURN_CTOR(code);
}
