PHP_METHOD(Phalcon_Validation_Validator_Date, checkDate) {
zend_bool _3;
zend_class_entry *_0, *_1;
int ZEPHIR_LAST_CALL_STATUS;
zval *value, *format, *date = NULL, *errors = NULL, *_2, *_4;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &value, &format);
if (!(Z_TYPE_P(value) == IS_STRING)) {
RETURN_MM_BOOL(0);
}
_0 = zend_fetch_class(SL("DateTime"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
ZEPHIR_CALL_CE_STATIC(&date, _0, "createfromformat", NULL, 0, format, value);
zephir_check_call_status();
_1 = zend_fetch_class(SL("DateTime"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
ZEPHIR_CALL_CE_STATIC(&errors, _1, "getlasterrors", NULL, 0);
zephir_check_call_status();
zephir_array_fetch_string(&_2, errors, SL("warning_count"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/date.zep", 121 TSRMLS_CC);
_3 = ZEPHIR_GT_LONG(_2, 0);
if (!(_3)) {
zephir_array_fetch_string(&_4, errors, SL("error_count"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/date.zep", 121 TSRMLS_CC);
_3 = ZEPHIR_GT_LONG(_4, 0);
}
if (_3) {
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
PHP_METHOD(Test_Statements, testElseIf2) {
zval *num_param = NULL, *total, total_sub;
int num;
zval this_zv;
zval *this_ptr = getThis();
if (EXPECTED(this_ptr)) {
ZVAL_OBJ(&this_zv, Z_OBJ_P(this_ptr));
this_ptr = &this_zv;
} else this_ptr = NULL;
ZVAL_UNDEF(&total_sub);
zephir_fetch_params(0, 2, 0, &num_param, &total);
num = zephir_get_intval(num_param);
if (ZEPHIR_GT_LONG(total, num)) {
RETURN_STRING("less");
} else if (ZEPHIR_IS_LONG(total, num)) {
RETURN_STRING("equal");
} else {
RETURN_STRING("else");
}
}
/**
* Gets row in a specific position of the resultset
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset, offsetGet) {
zval *index_param = NULL, *_0, *_1$$3;
int index, ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &index_param);
if (unlikely(Z_TYPE_P(index_param) != IS_LONG)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'index' must be a int") TSRMLS_CC);
RETURN_MM_NULL();
}
index = Z_LVAL_P(index_param);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_count"), PH_NOISY_CC);
if (ZEPHIR_GT_LONG(_0, index)) {
ZEPHIR_INIT_VAR(_1$$3);
ZVAL_LONG(_1$$3, index);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "seek", NULL, 70, _1$$3);
zephir_check_call_status();
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "current", NULL, 0);
zephir_check_call_status();
RETURN_MM();
}
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "The index does not exist in the cursor", "phalcon/mvc/model/resultset.zep", 285);
return;
}
PHP_METHOD(Test_Trie, getTrieNodeByKey) {
zend_class_entry *_5;
zephir_nts_static zephir_fcall_cache_entry *_2 = NULL;
int i, ZEPHIR_LAST_CALL_STATUS;
zend_bool create;
zval *key_param = NULL, *create_param = NULL, *trieNode = NULL, *keyLen, *character = NULL, _0 = zval_used_for_init, _1 = zval_used_for_init, *_3 = NULL, *_4 = NULL, *_6 = NULL, *_7;
zval *key = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &key_param, &create_param);
zephir_get_strval(key, key_param);
if (!create_param) {
create = 0;
} else {
create = zephir_get_boolval(create_param);
}
ZEPHIR_OBS_VAR(trieNode);
zephir_read_property_this(&trieNode, this_ptr, SL("trie"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(keyLen);
ZVAL_LONG(keyLen, zephir_fast_strlen_ev(key));
i = 0;
while (1) {
if (!(ZEPHIR_GT_LONG(keyLen, i))) {
break;
}
ZEPHIR_SINIT_NVAR(_0);
ZVAL_LONG(&_0, i);
ZEPHIR_SINIT_NVAR(_1);
ZVAL_LONG(&_1, 1);
ZEPHIR_CALL_FUNCTION(&character, "substr", &_2, key, &_0, &_1);
zephir_check_call_status();
ZEPHIR_OBS_NVAR(_3);
zephir_read_property(&_3, trieNode, SL("children"), PH_NOISY_CC);
if (!(zephir_array_isset(_3, character))) {
if (create) {
ZEPHIR_INIT_LNVAR(_4);
_5 = zend_fetch_class(SL("tries\\trienode"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
object_init_ex(_4, _5);
if (zephir_has_constructor(_4 TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, _4, "__construct", NULL);
zephir_check_call_status();
}
zephir_update_property_array(trieNode, SL("children"), character, _4 TSRMLS_CC);
} else {
RETURN_MM_BOOL(0);
}
}
ZEPHIR_OBS_NVAR(_6);
zephir_read_property(&_6, trieNode, SL("children"), PH_NOISY_CC);
zephir_array_fetch(&_7, _6, character, PH_NOISY | PH_READONLY TSRMLS_CC);
ZEPHIR_CPY_WRT(trieNode, _7);
i += 1;
}
RETURN_CCTOR(trieNode);
}
/**
* Check if messages were generated for a specific element
*/
PHP_METHOD(Phalcon_Forms_Form, hasMessagesFor) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *name_param = NULL, *_0 = NULL, *_1 = NULL;
zval *name = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &name_param);
if (UNEXPECTED(Z_TYPE_P(name_param) != IS_STRING && Z_TYPE_P(name_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'name' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(name_param) == IS_STRING)) {
zephir_get_strval(name, name_param);
} else {
ZEPHIR_INIT_VAR(name);
ZVAL_EMPTY_STRING(name);
}
ZEPHIR_CALL_METHOD(&_0, this_ptr, "getmessagesfor", NULL, 0, name);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_1, _0, "count", NULL, 0);
zephir_check_call_status();
RETURN_MM_BOOL(ZEPHIR_GT_LONG(_1, 0));
}
PHP_METHOD(Test_Flow, testWhile13) {
zval _0;
int a;
zval b;
zval this_zv;
zval *this_ptr = getThis();
if (EXPECTED(this_ptr)) {
ZVAL_OBJ(&this_zv, Z_OBJ_P(this_ptr));
this_ptr = &this_zv;
} else this_ptr = NULL;
ZVAL_UNDEF(&b);
ZVAL_UNDEF(&_0);
ZEPHIR_MM_GROW();
a = 5;
ZEPHIR_INIT_VAR(&_0);
ZEPHIR_CONCAT_SS(&_0, "+", "10");
ZEPHIR_CPY_WRT(&b, &_0);
while (1) {
if (!(ZEPHIR_GT_LONG(&b, a))) {
break;
}
ZEPHIR_SEPARATE(&b);
zephir_decrement(&b);
}
RETURN_CCTOR(b);
}
PHP_METHOD(Test_Flow, testWhile13) {
zval _0;
int a;
zval b;
ZEPHIR_INIT_THIS();
ZVAL_UNDEF(&b);
ZVAL_UNDEF(&_0);
ZEPHIR_MM_GROW();
a = 5;
ZEPHIR_INIT_VAR(&_0);
ZEPHIR_CONCAT_SS(&_0, "+", "10");
ZEPHIR_CPY_WRT(&b, &_0);
while (1) {
if (!(ZEPHIR_GT_LONG(&b, a))) {
break;
}
ZEPHIR_SEPARATE(&b);
zephir_decrement(&b);
}
RETURN_CCTOR(b);
}
/**
* Checks whether the manager has an active transaction
*/
PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, has) {
zval *_0;
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_number"), PH_NOISY_CC);
RETURN_BOOL(ZEPHIR_GT_LONG(_0, 0));
}
/**
* @link https://github.com/phalcon/zephir/issues/709
*/
PHP_METHOD(Test_NativeArray, issue709) {
zend_bool works, _0, _7$$3;
zval c, arr, _3$$3, _4$$3, _5$$3;
zend_long ZEPHIR_LAST_CALL_STATUS, _1, _2;
zephir_fcall_cache_entry *_6 = NULL;
zval *this_ptr = getThis();
ZVAL_UNDEF(&c);
ZVAL_UNDEF(&arr);
ZVAL_UNDEF(&_3$$3);
ZVAL_UNDEF(&_4$$3);
ZVAL_UNDEF(&_5$$3);
ZEPHIR_MM_GROW();
works = 1;
_2 = 50;
_1 = 0;
_0 = 0;
if (_1 <= _2) {
while (1) {
if (_0) {
_1++;
if (!(_1 <= _2)) {
break;
}
} else {
_0 = 1;
}
ZEPHIR_INIT_NVAR(&c);
ZVAL_LONG(&c, _1);
ZEPHIR_INIT_NVAR(&arr);
zephir_create_array(&arr, 2, 0 TSRMLS_CC);
ZEPHIR_INIT_NVAR(&_3$$3);
ZVAL_LONG(&_3$$3, 1);
zephir_array_fast_append(&arr, &_3$$3);
ZEPHIR_INIT_NVAR(&_3$$3);
ZVAL_LONG(&_3$$3, 2);
zephir_array_fast_append(&arr, &_3$$3);
ZEPHIR_CALL_FUNCTION(&_5$$3, "array_rand", &_6, 52, &arr);
zephir_check_call_status();
zephir_array_fetch(&_4$$3, &arr, &_5$$3, PH_NOISY | PH_READONLY, "test/nativearray.zep", 626 TSRMLS_CC);
ZEPHIR_CPY_WRT(&arr, &_4$$3);
_7$$3 = ZEPHIR_LT_LONG(&arr, 0);
if (!(_7$$3)) {
_7$$3 = ZEPHIR_GT_LONG(&arr, 2);
}
if (_7$$3) {
works = 0;
}
}
}
RETURN_MM_BOOL(works);
}
/**
* Concatenates strings using the separator only once without duplication in places concatenation
*
* <code>
* $str = Phalcon\Text::concat("/", "/tmp/", "/folder_1/", "/folder_2", "folder_3/");
* echo $str; // /tmp/folder_1/folder_2/folder_3/
* </code>
*
* @param string separator
* @param string a
* @param string b
* @param string ...N
*/
PHP_METHOD(Phalcon_Text, concat) {
HashTable *_7$$3;
HashPosition _6$$3;
zval *separator = NULL, *a = NULL, *b = NULL, _0 = zval_used_for_init, *c = NULL, *_2 = NULL, *_12, *_13, *_3$$3 = NULL, _4$$3, *_5$$3 = NULL, **_8$$3, *_9$$4 = NULL, *_10$$4 = NULL, *_11$$4 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_1 = NULL;
ZEPHIR_MM_GROW();
ZEPHIR_SINIT_VAR(_0);
ZVAL_LONG(&_0, 0);
ZEPHIR_CALL_FUNCTION(&separator, "func_get_arg", &_1, 443, &_0);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_0);
ZVAL_LONG(&_0, 1);
ZEPHIR_CALL_FUNCTION(&a, "func_get_arg", &_1, 443, &_0);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_0);
ZVAL_LONG(&_0, 2);
ZEPHIR_CALL_FUNCTION(&b, "func_get_arg", &_1, 443, &_0);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&_2, "func_num_args", NULL, 444);
zephir_check_call_status();
if (ZEPHIR_GT_LONG(_2, 3)) {
ZEPHIR_CALL_FUNCTION(&_3$$3, "func_get_args", NULL, 172);
zephir_check_call_status();
ZEPHIR_SINIT_VAR(_4$$3);
ZVAL_LONG(&_4$$3, 3);
ZEPHIR_CALL_FUNCTION(&_5$$3, "array_slice", NULL, 391, _3$$3, &_4$$3);
zephir_check_call_status();
zephir_is_iterable(_5$$3, &_7$$3, &_6$$3, 0, 0, "phalcon/text.zep", 245);
for (
; zephir_hash_get_current_data_ex(_7$$3, (void**) &_8$$3, &_6$$3) == SUCCESS
; zephir_hash_move_forward_ex(_7$$3, &_6$$3)
) {
ZEPHIR_GET_HVALUE(c, _8$$3);
ZEPHIR_INIT_NVAR(_9$$4);
zephir_fast_trim(_9$$4, b, separator, ZEPHIR_TRIM_RIGHT TSRMLS_CC);
ZEPHIR_INIT_NVAR(_10$$4);
zephir_fast_trim(_10$$4, c, separator, ZEPHIR_TRIM_LEFT TSRMLS_CC);
ZEPHIR_INIT_LNVAR(_11$$4);
ZEPHIR_CONCAT_VVV(_11$$4, _9$$4, separator, _10$$4);
ZEPHIR_CPY_WRT(b, _11$$4);
}
}
ZEPHIR_INIT_VAR(_12);
zephir_fast_trim(_12, a, separator, ZEPHIR_TRIM_RIGHT TSRMLS_CC);
ZEPHIR_INIT_VAR(_13);
zephir_fast_trim(_13, b, separator, ZEPHIR_TRIM_LEFT TSRMLS_CC);
ZEPHIR_CONCAT_VVV(return_value, _12, separator, _13);
RETURN_MM();
}
PHP_METHOD(Test_Arithmetic, greater4) {
zval *a;
zephir_fetch_params(0, 1, 0, &a);
RETURN_BOOL(ZEPHIR_GT_LONG(a, 5.0));
}
/**
* Concatenates strings using the separator only once without duplication in places concatenation
*
* <code>
* $str = Phalcon\Text::concat("/", "/tmp/", "/folder_1/", "/folder_2", "folder_3/");
* echo $str; // /tmp/folder_1/folder_2/folder_3/
* </code>
*
* @param string separator
* @param string a
* @param string b
* @param string ...N
*/
PHP_METHOD(Phalcon_Text, concat) {
HashTable *_6;
HashPosition _5;
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_1 = NULL;
zval *separator = NULL, *a = NULL, *b = NULL, _0 = zval_used_for_init, *c = NULL, *_2 = NULL, *_3 = NULL, *_4 = NULL, **_7, *_8 = NULL, *_9 = NULL, *_10 = NULL;
ZEPHIR_MM_GROW();
ZEPHIR_SINIT_VAR(_0);
ZVAL_LONG(&_0, 0);
ZEPHIR_CALL_FUNCTION(&separator, "func_get_arg", &_1, 418, &_0);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_0);
ZVAL_LONG(&_0, 1);
ZEPHIR_CALL_FUNCTION(&a, "func_get_arg", &_1, 418, &_0);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_0);
ZVAL_LONG(&_0, 2);
ZEPHIR_CALL_FUNCTION(&b, "func_get_arg", &_1, 418, &_0);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&_2, "func_num_args", NULL, 419);
zephir_check_call_status();
if (ZEPHIR_GT_LONG(_2, 3)) {
ZEPHIR_CALL_FUNCTION(&_3, "func_get_args", NULL, 165);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_0);
ZVAL_LONG(&_0, 3);
ZEPHIR_CALL_FUNCTION(&_4, "array_slice", NULL, 377, _3, &_0);
zephir_check_call_status();
zephir_is_iterable(_4, &_6, &_5, 0, 0, "phalcon/text.zep", 246);
for (
; zephir_hash_get_current_data_ex(_6, (void**) &_7, &_5) == SUCCESS
; zephir_hash_move_forward_ex(_6, &_5)
) {
ZEPHIR_GET_HVALUE(c, _7);
ZEPHIR_INIT_NVAR(_8);
zephir_fast_trim(_8, b, separator, ZEPHIR_TRIM_RIGHT TSRMLS_CC);
ZEPHIR_INIT_NVAR(_9);
zephir_fast_trim(_9, c, separator, ZEPHIR_TRIM_LEFT TSRMLS_CC);
ZEPHIR_INIT_LNVAR(_10);
ZEPHIR_CONCAT_VVV(_10, _8, separator, _9);
ZEPHIR_CPY_WRT(b, _10);
}
}
ZEPHIR_INIT_NVAR(_8);
zephir_fast_trim(_8, a, separator, ZEPHIR_TRIM_RIGHT TSRMLS_CC);
ZEPHIR_INIT_NVAR(_9);
zephir_fast_trim(_9, b, separator, ZEPHIR_TRIM_LEFT TSRMLS_CC);
ZEPHIR_CONCAT_VVV(return_value, _8, separator, _9);
RETURN_MM();
}
PHP_METHOD(Test_Statements, test544Issue) {
zephir_fcall_cache_entry *_8 = NULL;
zval *step_param = NULL, *_0, *_1, *_2, *_3, *_4, *_5, _6 = zval_used_for_init, *_7 = NULL, *_9, *_10, *_11 = NULL;
int step, filledWidth, unfilledWidth, ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &step_param);
if (unlikely(Z_TYPE_P(step_param) != IS_LONG)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'step' must be a long/integer") TSRMLS_CC);
RETURN_MM_NULL();
}
step = Z_LVAL_P(step_param);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("totalSteps"), PH_NOISY_CC);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("totalSteps"), PH_NOISY_CC);
if (ZEPHIR_GT_LONG(_0, step)) {
_2 = zephir_fetch_nproperty_this(this_ptr, SL("width"), PH_NOISY_CC);
_3 = zephir_fetch_nproperty_this(this_ptr, SL("totalSteps"), PH_NOISY_CC);
filledWidth = (long) ((zephir_safe_div_long_zval(((zephir_get_numberval(_2) - 1)), _3 TSRMLS_CC) * step));
_4 = zephir_fetch_nproperty_this(this_ptr, SL("width"), PH_NOISY_CC);
unfilledWidth = (((zephir_get_numberval(_4) - 1)) - filledWidth);
_5 = zephir_fetch_nproperty_this(this_ptr, SL("filledChar"), PH_NOISY_CC);
ZEPHIR_SINIT_VAR(_6);
ZVAL_LONG(&_6, filledWidth);
ZEPHIR_CALL_FUNCTION(&_7, "str_repeat", &_8, 17, _5, &_6);
zephir_check_call_status();
_9 = zephir_fetch_nproperty_this(this_ptr, SL("arrow"), PH_NOISY_CC);
_10 = zephir_fetch_nproperty_this(this_ptr, SL("unfilledChar"), PH_NOISY_CC);
ZEPHIR_SINIT_NVAR(_6);
ZVAL_LONG(&_6, unfilledWidth);
ZEPHIR_CALL_FUNCTION(&_11, "str_repeat", &_8, 17, _10, &_6);
zephir_check_call_status();
ZEPHIR_CONCAT_VVV(return_value, _7, _9, _11);
RETURN_MM();
} else if (ZEPHIR_IS_LONG_IDENTICAL(_1, step)) {
_2 = zephir_fetch_nproperty_this(this_ptr, SL("filledChar"), PH_NOISY_CC);
_3 = zephir_fetch_nproperty_this(this_ptr, SL("width"), PH_NOISY_CC);
ZEPHIR_RETURN_CALL_FUNCTION("str_repeat", &_8, 17, _2, _3);
zephir_check_call_status();
RETURN_MM();
} else {
_2 = zephir_fetch_nproperty_this(this_ptr, SL("unfilledChar"), PH_NOISY_CC);
_3 = zephir_fetch_nproperty_this(this_ptr, SL("width"), PH_NOISY_CC);
ZEPHIR_RETURN_CALL_FUNCTION("str_repeat", &_8, 17, _2, _3);
zephir_check_call_status();
RETURN_MM();
}
}
/**
* Checks whether offset exists in the resultset
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset, offsetExists) {
zval *index_param = NULL, *_0;
int index;
zephir_fetch_params(0, 1, 0, &index_param);
index = zephir_get_intval(index_param);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_count"), PH_NOISY_CC);
RETURN_BOOL(ZEPHIR_GT_LONG(_0, index));
}
/**
* Commits the active transaction in the connection
*
* @param boolean nesting
* @return boolean
*/
PHP_METHOD(Pdm_Db_Adapter_AbstractPdo, commit) {
int ZEPHIR_LAST_CALL_STATUS;
zval *nesting_param = NULL, *transactionLevel = NULL, *savepointName = NULL, *_0, *_1 = NULL;
zend_bool nesting;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &nesting_param);
if (!nesting_param) {
nesting = 1;
} else {
nesting = zephir_get_boolval(nesting_param);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("transactionLevel"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(transactionLevel, _0);
if (!(zephir_is_true(transactionLevel))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(pdm_db_adapter_exception_ce, "There is no active transaction", "pdm/db/adapter/abstractpdo.zep", 473);
return;
}
if (ZEPHIR_IS_LONG(transactionLevel, 1)) {
RETURN_ON_FAILURE(zephir_property_decr(this_ptr, SL("transactionLevel") TSRMLS_CC));
_0 = zephir_fetch_nproperty_this(this_ptr, SL("pdo"), PH_NOISY_CC);
ZEPHIR_RETURN_CALL_METHOD(_0, "commit", NULL);
zephir_check_call_status();
RETURN_MM();
} else {
if (zephir_is_true(transactionLevel)) {
if (nesting) {
ZEPHIR_CALL_METHOD(&_1, this_ptr, "isnestedtransactionswithsavepoints", NULL);
zephir_check_call_status();
if (zephir_is_true(_1)) {
ZEPHIR_CALL_METHOD(&savepointName, this_ptr, "getnestedtransactionsavepointname", NULL);
zephir_check_call_status();
RETURN_ON_FAILURE(zephir_property_decr(this_ptr, SL("transactionLevel") TSRMLS_CC));
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "releasesavepoint", NULL, savepointName);
zephir_check_call_status();
RETURN_MM();
}
}
}
}
if (ZEPHIR_GT_LONG(transactionLevel, 0)) {
RETURN_ON_FAILURE(zephir_property_decr(this_ptr, SL("transactionLevel") TSRMLS_CC));
}
RETURN_MM_BOOL(0);
}
PHP_METHOD(PocketMine_Level_Generator_Noise_Generator, noise3D) {
zephir_fcall_cache_entry *_5 = NULL;
int i = 0, ZEPHIR_LAST_CALL_STATUS;
zend_bool normalized;
zval *x_param = NULL, *y_param = NULL, *z_param = NULL, *normalized_param = NULL, *_0, *_1 = NULL, *_2 = NULL, *_3 = NULL, *_4 = NULL, *_6, *_7;
double x, y, z, result = 0, amp = 1, freq = 1, max = 0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 1, &x_param, &y_param, &z_param, &normalized_param);
x = zephir_get_doubleval(x_param);
y = zephir_get_doubleval(y_param);
z = zephir_get_doubleval(z_param);
if (!normalized_param) {
normalized = 0;
} else {
normalized = zephir_get_boolval(normalized_param);
}
while (1) {
_0 = zephir_fetch_nproperty_this(this_ptr, SL("octaves"), PH_NOISY_CC);
if (!(ZEPHIR_GT_LONG(_0, i))) {
break;
}
ZEPHIR_INIT_NVAR(_2);
ZVAL_DOUBLE(_2, (x * freq));
ZEPHIR_INIT_NVAR(_3);
ZVAL_DOUBLE(_3, (y * freq));
ZEPHIR_INIT_NVAR(_4);
ZVAL_DOUBLE(_4, (z * freq));
ZEPHIR_CALL_METHOD(&_1, this_ptr, "getnoise3d", &_5, _2, _3, _4);
zephir_check_call_status();
result += (double) (zephir_get_doubleval(_1) * amp);
max += amp;
_6 = zephir_fetch_nproperty_this(this_ptr, SL("frequency"), PH_NOISY_CC);
freq *= zephir_get_numberval(_6);
_7 = zephir_fetch_nproperty_this(this_ptr, SL("amplitude"), PH_NOISY_CC);
amp *= zephir_get_numberval(_7);
i++;
}
if (normalized == 1) {
result = (result / max);
}
RETURN_MM_DOUBLE(result);
}
/**
* Returns the translation related to the given key
*
* @param string index
* @param array placeholders
* @param string domain
* @return string
*/
PHP_METHOD(Phalcon_Translate_Adapter_Gettext, query) {
int ZEPHIR_LAST_CALL_STATUS;
zval *index_param = NULL, *placeholders = NULL, *translation = NULL, *domain = NULL, *_0 = NULL, _1;
zval *index = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &index_param, &placeholders);
if (unlikely(Z_TYPE_P(index_param) != IS_STRING && Z_TYPE_P(index_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'index' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(index_param) == IS_STRING)) {
zephir_get_strval(index, index_param);
} else {
ZEPHIR_INIT_VAR(index);
ZVAL_EMPTY_STRING(index);
}
if (!placeholders) {
placeholders = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_CALL_FUNCTION(&_0, "func_num_args", NULL, 416);
zephir_check_call_status();
if (ZEPHIR_GT_LONG(_0, 2)) {
ZEPHIR_SINIT_VAR(_1);
ZVAL_LONG(&_1, 2);
ZEPHIR_CALL_FUNCTION(&domain, "func_get_arg", NULL, 415, &_1);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(domain);
ZVAL_NULL(domain);
}
if (!(zephir_is_true(domain))) {
ZEPHIR_CALL_FUNCTION(&translation, "gettext", NULL, 418, index);
zephir_check_call_status();
} else {
ZEPHIR_CALL_FUNCTION(&translation, "dgettext", NULL, 419, domain, index);
zephir_check_call_status();
}
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "replaceplaceholders", NULL, 0, translation, placeholders);
zephir_check_call_status();
RETURN_MM();
}
/**
* Checks whether offset exists in the resultset
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset, offsetExists) {
zephir_nts_static zephir_fcall_cache_entry *_1 = NULL;
zval *index_param = NULL, *_0 = NULL;
int index, ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &index_param);
index = zephir_get_intval(index_param);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "count", &_1);
zephir_check_call_status();
RETURN_MM_BOOL(ZEPHIR_GT_LONG(_0, index));
}
/**
* Gets row in a specific position of the resultset
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset, offsetGet) {
zephir_nts_static zephir_fcall_cache_entry *_1 = NULL, *_3 = NULL, *_5 = NULL;
zval *index_param = NULL, *_0 = NULL, *_2, _4, *_6 = NULL;
int index, ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &index_param);
if (unlikely(Z_TYPE_P(index_param) != IS_LONG)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'index' must be a long/integer") TSRMLS_CC);
RETURN_MM_NULL();
}
index = Z_LVAL_P(index_param);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "count", &_1);
zephir_check_call_status();
if (ZEPHIR_GT_LONG(_0, index)) {
_2 = zephir_fetch_nproperty_this(this_ptr, SL("_pointer"), PH_NOISY_CC);
if (ZEPHIR_IS_LONG(_2, index)) {
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "current", &_3);
zephir_check_call_status();
RETURN_MM();
}
ZEPHIR_SINIT_VAR(_4);
ZVAL_LONG(&_4, index);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "seek", &_5, &_4);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_6, this_ptr, "valid", NULL);
zephir_check_call_status();
if (!ZEPHIR_IS_FALSE_IDENTICAL(_6)) {
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "current", &_3);
zephir_check_call_status();
RETURN_MM();
}
RETURN_MM_BOOL(0);
}
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "The index does not exist in the cursor", "phalcon/mvc/model/resultset.zep", 272);
return;
}
/**
* Phalcon\Mvc\Model\Resultset\Simple constructor
*
* @param array columnMap
* @param Phalcon\Mvc\ModelInterface|Phalcon\Mvc\Model\Row model
* @param Phalcon\Db\Result\Pdo|null result
* @param Phalcon\Cache\BackendInterface cache
* @param boolean keepSnapshots
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, __construct) {
int ZEPHIR_LAST_CALL_STATUS;
zval *columnMap, *model, *result, *cache = NULL, *keepSnapshots = NULL, *rowCount = NULL, *_0, *_1;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 2, &columnMap, &model, &result, &cache, &keepSnapshots);
if (!cache) {
cache = ZEPHIR_GLOBAL(global_null);
}
if (!keepSnapshots) {
keepSnapshots = ZEPHIR_GLOBAL(global_null);
}
zephir_update_property_this(this_ptr, SL("_model"), model TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_result"), result TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_cache"), cache TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_columnMap"), columnMap TSRMLS_CC);
if (Z_TYPE_P(result) != IS_OBJECT) {
RETURN_MM_NULL();
}
ZEPHIR_INIT_VAR(_0);
ZVAL_LONG(_0, 1);
ZEPHIR_CALL_METHOD(NULL, result, "setfetchmode", NULL, _0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&rowCount, result, "numrows", NULL);
zephir_check_call_status();
if (ZEPHIR_GT_LONG(rowCount, 32)) {
ZEPHIR_INIT_ZVAL_NREF(_1);
ZVAL_LONG(_1, 1);
zephir_update_property_this(this_ptr, SL("_type"), _1 TSRMLS_CC);
} else {
ZEPHIR_INIT_ZVAL_NREF(_1);
ZVAL_LONG(_1, 0);
zephir_update_property_this(this_ptr, SL("_type"), _1 TSRMLS_CC);
}
zephir_update_property_this(this_ptr, SL("_count"), rowCount TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_keepSnapshots"), keepSnapshots TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Test_Statements, testElseIf2) {
zval *num_param = NULL, *total;
int num;
zephir_fetch_params(0, 2, 0, &num_param, &total);
num = zephir_get_intval(num_param);
if (ZEPHIR_GT_LONG(total, num)) {
RETURN_STRING("less", 1);
} else if (ZEPHIR_IS_LONG(total, num)) {
RETURN_STRING("equal", 1);
} else {
RETURN_STRING("else", 1);
}
}
PHP_METHOD(Test_Flow, testWhile12) {
zval *_0;
zval *b = NULL;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(_0);
ZEPHIR_CONCAT_SS(_0, "+", "10");
ZEPHIR_CPY_WRT(b, _0);
while (1) {
if (!(ZEPHIR_GT_LONG(b, 5))) {
break;
}
ZEPHIR_SEPARATE(b);
zephir_decrement(b);
}
RETURN_CCTOR(b);
}
PHP_METHOD(Test_Flow, testWhile12) {
zval _0;
zval b;
zval *this_ptr = getThis();
ZVAL_UNDEF(&b);
ZVAL_UNDEF(&_0);
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(&_0);
ZEPHIR_CONCAT_SS(&_0, "+", "10");
ZEPHIR_CPY_WRT(&b, &_0);
while (1) {
if (!(ZEPHIR_GT_LONG(&b, 5))) {
break;
}
ZEPHIR_SEPARATE(&b);
zephir_decrement(&b);
}
RETURN_CCTOR(&b);
}
/**
* Create internal connection to redis
*/
PHP_METHOD(Phalcon_Cache_Backend_Redis, _connect) {
zend_bool _0, _1, _2, _5, _7;
zval *options = NULL, *redis = NULL, *persistent = NULL, *success = NULL, *host = NULL, *port = NULL, *auth = NULL, *index = NULL, *timeout = NULL, *_6, *_3$$6, *_4$$6;
zend_long ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(options);
zephir_read_property_this(&options, this_ptr, SL("_options"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(redis);
object_init_ex(redis, zephir_get_internal_ce(SS("redis") TSRMLS_CC));
if (zephir_has_constructor(redis TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, redis, "__construct", NULL, 0);
zephir_check_call_status();
}
ZEPHIR_OBS_VAR(host);
_0 = !(zephir_array_isset_string_fetch(&host, options, SS("host"), 0 TSRMLS_CC));
if (!(_0)) {
ZEPHIR_OBS_VAR(port);
_0 = !(zephir_array_isset_string_fetch(&port, options, SS("port"), 0 TSRMLS_CC));
}
_1 = _0;
if (!(_1)) {
ZEPHIR_OBS_VAR(persistent);
_1 = !(zephir_array_isset_string_fetch(&persistent, options, SS("persistent"), 0 TSRMLS_CC));
}
_2 = _1;
if (!(_2)) {
ZEPHIR_OBS_VAR(timeout);
_2 = !(zephir_array_isset_string_fetch(&timeout, options, SS("timeout"), 0 TSRMLS_CC));
}
if (_2) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options", "phalcon/cache/backend/redis.zep", 120);
return;
}
if (zephir_is_true(persistent)) {
ZEPHIR_CALL_METHOD(&success, redis, "pconnect", NULL, 0, host, port, timeout);
zephir_check_call_status();
} else {
ZEPHIR_CALL_METHOD(&success, redis, "connect", NULL, 0, host, port, timeout);
zephir_check_call_status();
}
if (!(zephir_is_true(success))) {
ZEPHIR_INIT_VAR(_3$$6);
object_init_ex(_3$$6, phalcon_cache_exception_ce);
ZEPHIR_INIT_VAR(_4$$6);
ZEPHIR_CONCAT_SVSV(_4$$6, "Could not connect to the Redisd server ", host, ":", port);
ZEPHIR_CALL_METHOD(NULL, _3$$6, "__construct", NULL, 9, _4$$6);
zephir_check_call_status();
zephir_throw_exception_debug(_3$$6, "phalcon/cache/backend/redis.zep", 130 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_OBS_VAR(auth);
_5 = zephir_array_isset_string_fetch(&auth, options, SS("auth"), 0 TSRMLS_CC);
if (_5) {
zephir_array_fetch_string(&_6, options, SL("auth"), PH_NOISY | PH_READONLY, "phalcon/cache/backend/redis.zep", 133 TSRMLS_CC);
_5 = !(ZEPHIR_IS_EMPTY(_6));
}
if (_5) {
ZEPHIR_CALL_METHOD(&success, redis, "auth", NULL, 0, auth);
zephir_check_call_status();
if (!(zephir_is_true(success))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Failed to authenticate with the Redisd server", "phalcon/cache/backend/redis.zep", 137);
return;
}
}
ZEPHIR_OBS_VAR(index);
_7 = zephir_array_isset_string_fetch(&index, options, SS("index"), 0 TSRMLS_CC);
if (_7) {
_7 = ZEPHIR_GT_LONG(index, 0);
}
if (_7) {
ZEPHIR_CALL_METHOD(&success, redis, "select", NULL, 0, index);
zephir_check_call_status();
if (!(zephir_is_true(success))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Redis server selected database failed", "phalcon/cache/backend/redis.zep", 145);
return;
}
}
zephir_update_property_this(getThis(), SL("_redis"), redis TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Test_Statements, test544Issue) {
zephir_fcall_cache_entry *_8 = NULL;
zval *step_param = NULL, _0, _1, _2$$3, _3$$3, _4$$3, _5$$3, _6$$3, _7$$3, _9$$3, _10$$3, _11$$3, _12$$4, _13$$4, _14$$5, _15$$5;
int step, ZEPHIR_LAST_CALL_STATUS, filledWidth = 0, unfilledWidth = 0;
zval this_zv;
zval *this_ptr = getThis();
if (EXPECTED(this_ptr)) {
ZVAL_OBJ(&this_zv, Z_OBJ_P(this_ptr));
this_ptr = &this_zv;
} else this_ptr = NULL;
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1);
ZVAL_UNDEF(&_2$$3);
ZVAL_UNDEF(&_3$$3);
ZVAL_UNDEF(&_4$$3);
ZVAL_UNDEF(&_5$$3);
ZVAL_UNDEF(&_6$$3);
ZVAL_UNDEF(&_7$$3);
ZVAL_UNDEF(&_9$$3);
ZVAL_UNDEF(&_10$$3);
ZVAL_UNDEF(&_11$$3);
ZVAL_UNDEF(&_12$$4);
ZVAL_UNDEF(&_13$$4);
ZVAL_UNDEF(&_14$$5);
ZVAL_UNDEF(&_15$$5);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &step_param);
if (unlikely(Z_TYPE_P(step_param) != IS_LONG)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'step' must be a int") TSRMLS_CC);
RETURN_MM_NULL();
}
step = Z_LVAL_P(step_param);
zephir_read_property(&_0, this_ptr, SL("totalSteps"), PH_NOISY_CC | PH_READONLY);
zephir_read_property(&_1, this_ptr, SL("totalSteps"), PH_NOISY_CC | PH_READONLY);
if (ZEPHIR_GT_LONG(&_0, step)) {
zephir_read_property(&_2$$3, this_ptr, SL("width"), PH_NOISY_CC | PH_READONLY);
zephir_read_property(&_3$$3, this_ptr, SL("totalSteps"), PH_NOISY_CC | PH_READONLY);
filledWidth = (long) ((zephir_safe_div_long_zval(((zephir_get_numberval(&_2$$3) - 1)), &_3$$3 TSRMLS_CC) * step));
zephir_read_property(&_4$$3, this_ptr, SL("width"), PH_NOISY_CC | PH_READONLY);
unfilledWidth = (((zephir_get_numberval(&_4$$3) - 1)) - filledWidth);
zephir_read_property(&_5$$3, this_ptr, SL("filledChar"), PH_NOISY_CC | PH_READONLY);
ZVAL_LONG(&_6$$3, filledWidth);
ZEPHIR_CALL_FUNCTION(&_7$$3, "str_repeat", &_8, 17, &_5$$3, &_6$$3);
zephir_check_call_status();
zephir_read_property(&_6$$3, this_ptr, SL("arrow"), PH_NOISY_CC | PH_READONLY);
zephir_read_property(&_9$$3, this_ptr, SL("unfilledChar"), PH_NOISY_CC | PH_READONLY);
ZVAL_LONG(&_10$$3, unfilledWidth);
ZEPHIR_CALL_FUNCTION(&_11$$3, "str_repeat", &_8, 17, &_9$$3, &_10$$3);
zephir_check_call_status();
ZEPHIR_CONCAT_VVV(return_value, &_7$$3, &_6$$3, &_11$$3);
RETURN_MM();
} else if (ZEPHIR_IS_LONG_IDENTICAL(&_1, step)) {
zephir_read_property(&_12$$4, this_ptr, SL("filledChar"), PH_NOISY_CC | PH_READONLY);
zephir_read_property(&_13$$4, this_ptr, SL("width"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_RETURN_CALL_FUNCTION("str_repeat", &_8, 17, &_12$$4, &_13$$4);
zephir_check_call_status();
RETURN_MM();
} else {
zephir_read_property(&_14$$5, this_ptr, SL("unfilledChar"), PH_NOISY_CC | PH_READONLY);
zephir_read_property(&_15$$5, this_ptr, SL("width"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_RETURN_CALL_FUNCTION("str_repeat", &_8, 17, &_14$$5, &_15$$5);
zephir_check_call_status();
RETURN_MM();
}
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_File, validate) {
zend_bool _1, _2, _3, _5, _6, _13, _14, _16, _22, _23, _53, _60$$16, _67$$21;
zephir_fcall_cache_entry *_11 = NULL, *_12 = NULL, *_36 = NULL;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *field = NULL;
zval *validation, *field_param = NULL, *_SERVER, *_POST, *_FILES, *value = NULL, *message = NULL, *label = NULL, *replacePairs = NULL, *types = NULL, *byteUnits = NULL, *unit = NULL, *maxSize = NULL, *matches = NULL, *bytes = NULL, *mime = NULL, *tmp = NULL, *width = NULL, *height = NULL, *minResolution = NULL, *maxResolution = NULL, *minWidth = NULL, *maxWidth = NULL, *minHeight = NULL, *maxHeight = NULL, *fieldTypes = NULL, *code = NULL, *minResolutionArray = NULL, *maxResolutionArray = NULL, *_0, *_4, *_7, *_15, *_17, *_18 = NULL, *_27 = NULL, *_28 = NULL, *_45 = NULL, *_52 = NULL, *_54 = NULL, *_8$$3 = NULL, *_9$$3 = NULL, *_10$$3 = NULL, *_19$$4 = NULL, *_20$$4 = NULL, *_21$$4 = NULL, *_24$$5 = NULL, *_25$$5 = NULL, *_26$$5 = NULL, *_29$$6 = NULL, *_31$$6, *_32$$6, *_33$$6, *_34$$6, *_35$$6 = NULL, *_37$$6, *_38$$6, _39$$6, *_40$$6, *_41$$6 = NULL, *_30$$7, *_42$$9 = NULL, *_43$$9 = NULL, *_44$$9 = NULL, *_46$$10, _47$$13, *_48$$13, *_49$$15 = NULL, *_50$$15 = NULL, *_51$$15 = NULL, *_55$$16, *_56$$16 = NULL, *_57$$16 = NULL, *_64$$16 = NULL, *_58$$17, *_59$$18, *_61$$20 = NULL, *_62$$20 = NULL, *_63$$20 = NULL, *_65$$21, *_66$$22, *_68$$23 = NULL, *_69$$23 = NULL, *_70$$23 = NULL;
ZEPHIR_MM_GROW();
zephir_get_global(&_FILES, SS("_FILES") TSRMLS_CC);
zephir_get_global(&_POST, SS("_POST") TSRMLS_CC);
zephir_get_global(&_SERVER, SS("_SERVER") TSRMLS_CC);
zephir_fetch_params(1, 2, 0, &validation, &field_param);
if (UNEXPECTED(Z_TYPE_P(field_param) != IS_STRING && Z_TYPE_P(field_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'field' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(field_param) == IS_STRING)) {
zephir_get_strval(field, field_param);
} else {
ZEPHIR_INIT_VAR(field);
ZVAL_EMPTY_STRING(field);
}
ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&label, this_ptr, "preparelabel", NULL, 0, validation, field);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&code, this_ptr, "preparecode", NULL, 0, field);
zephir_check_call_status();
zephir_array_fetch_string(&_0, _SERVER, SL("REQUEST_METHOD"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 109 TSRMLS_CC);
_1 = ZEPHIR_IS_STRING(_0, "POST");
if (_1) {
_1 = ZEPHIR_IS_EMPTY(_POST);
}
_2 = _1;
if (_2) {
_2 = ZEPHIR_IS_EMPTY(_FILES);
}
_3 = _2;
if (_3) {
zephir_array_fetch_string(&_4, _SERVER, SL("CONTENT_LENGTH"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 109 TSRMLS_CC);
_3 = ZEPHIR_GT_LONG(_4, 0);
}
_5 = _3;
if (!(_5)) {
_6 = zephir_array_isset_string(value, SS("error"));
if (_6) {
zephir_array_fetch_string(&_7, value, SL("error"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 109 TSRMLS_CC);
_6 = ZEPHIR_IS_LONG_IDENTICAL(_7, 1);
}
_5 = _6;
}
if (_5) {
ZEPHIR_INIT_VAR(_8$$3);
ZVAL_STRING(_8$$3, "FileIniSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_9$$3);
ZVAL_STRING(_9$$3, "messageIniSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, _8$$3, _9$$3);
zephir_check_temp_parameter(_8$$3);
zephir_check_temp_parameter(_9$$3);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_8$$3);
object_init_ex(_8$$3, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_10$$3, "strtr", &_11, 27, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_9$$3);
ZVAL_STRING(_9$$3, "FileIniSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _8$$3, "__construct", &_12, 475, _10$$3, field, _9$$3, code);
zephir_check_temp_parameter(_9$$3);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _8$$3);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
_13 = !(zephir_array_isset_string(value, SS("error")));
if (!(_13)) {
_13 = !(zephir_array_isset_string(value, SS("tmp_name")));
}
_14 = _13;
if (!(_14)) {
zephir_array_fetch_string(&_15, value, SL("error"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 124 TSRMLS_CC);
_14 = !ZEPHIR_IS_LONG_IDENTICAL(_15, 0);
}
_16 = _14;
if (!(_16)) {
zephir_array_fetch_string(&_17, value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 124 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_18, "is_uploaded_file", NULL, 253, _17);
zephir_check_call_status();
_16 = !zephir_is_true(_18);
}
if (_16) {
ZEPHIR_INIT_VAR(_19$$4);
ZVAL_STRING(_19$$4, "FileEmpty", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_20$$4);
ZVAL_STRING(_20$$4, "messageEmpty", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, _19$$4, _20$$4);
zephir_check_temp_parameter(_19$$4);
zephir_check_temp_parameter(_20$$4);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_19$$4);
object_init_ex(_19$$4, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_21$$4, "strtr", &_11, 27, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_20$$4);
ZVAL_STRING(_20$$4, "FileEmpty", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _19$$4, "__construct", &_12, 475, _21$$4, field, _20$$4, code);
zephir_check_temp_parameter(_20$$4);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _19$$4);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
_22 = !(zephir_array_isset_string(value, SS("name")));
if (!(_22)) {
_22 = !(zephir_array_isset_string(value, SS("type")));
}
_23 = _22;
if (!(_23)) {
_23 = !(zephir_array_isset_string(value, SS("size")));
}
if (_23) {
ZEPHIR_INIT_VAR(_24$$5);
ZVAL_STRING(_24$$5, "FileValid", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_25$$5);
ZVAL_STRING(_25$$5, "messageValid", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, _24$$5, _25$$5);
zephir_check_temp_parameter(_24$$5);
zephir_check_temp_parameter(_25$$5);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_24$$5);
object_init_ex(_24$$5, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_26$$5, "strtr", &_11, 27, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_25$$5);
ZVAL_STRING(_25$$5, "FileValid", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _24$$5, "__construct", &_12, 475, _26$$5, field, _25$$5, code);
zephir_check_temp_parameter(_25$$5);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _24$$5);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_VAR(_28);
ZVAL_STRING(_28, "maxSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_27, this_ptr, "hasoption", NULL, 0, _28);
zephir_check_temp_parameter(_28);
zephir_check_call_status();
if (zephir_is_true(_27)) {
ZEPHIR_INIT_VAR(byteUnits);
zephir_create_array(byteUnits, 9, 0 TSRMLS_CC);
add_assoc_long_ex(byteUnits, SS("B"), 0);
add_assoc_long_ex(byteUnits, SS("K"), 10);
add_assoc_long_ex(byteUnits, SS("M"), 20);
add_assoc_long_ex(byteUnits, SS("G"), 30);
add_assoc_long_ex(byteUnits, SS("T"), 40);
add_assoc_long_ex(byteUnits, SS("KB"), 10);
add_assoc_long_ex(byteUnits, SS("MB"), 20);
add_assoc_long_ex(byteUnits, SS("GB"), 30);
add_assoc_long_ex(byteUnits, SS("TB"), 40);
ZEPHIR_INIT_VAR(_29$$6);
ZVAL_STRING(_29$$6, "maxSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&maxSize, this_ptr, "getoption", NULL, 0, _29$$6);
zephir_check_temp_parameter(_29$$6);
zephir_check_call_status();
ZEPHIR_INIT_VAR(matches);
ZVAL_NULL(matches);
ZEPHIR_INIT_VAR(unit);
ZVAL_STRING(unit, "B", 1);
if (Z_TYPE_P(maxSize) == IS_ARRAY) {
zephir_array_fetch(&_30$$7, maxSize, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 162 TSRMLS_CC);
ZEPHIR_CPY_WRT(maxSize, _30$$7);
}
ZEPHIR_INIT_NVAR(_29$$6);
ZEPHIR_INIT_VAR(_31$$6);
ZEPHIR_INIT_VAR(_32$$6);
zephir_array_keys(_32$$6, byteUnits TSRMLS_CC);
zephir_fast_join_str(_31$$6, SL("|"), _32$$6 TSRMLS_CC);
ZEPHIR_INIT_VAR(_33$$6);
ZEPHIR_CONCAT_SVS(_33$$6, "/^([0-9]+(?:\\.[0-9]+)?)(", _31$$6, ")?$/Di");
zephir_preg_match(_29$$6, _33$$6, maxSize, matches, 0, 0 , 0 TSRMLS_CC);
if (zephir_array_isset_long(matches, 2)) {
ZEPHIR_OBS_NVAR(unit);
zephir_array_fetch_long(&unit, matches, 2, PH_NOISY, "phalcon/validation/validator/file.zep", 168 TSRMLS_CC);
}
zephir_array_fetch_long(&_34$$6, matches, 1, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 171 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_35$$6, "floatval", &_36, 328, _34$$6);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_37$$6);
zephir_array_fetch(&_38$$6, byteUnits, unit, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 171 TSRMLS_CC);
ZEPHIR_SINIT_VAR(_39$$6);
ZVAL_LONG(&_39$$6, 2);
zephir_pow_function(_37$$6, &_39$$6, _38$$6);
ZEPHIR_INIT_VAR(bytes);
mul_function(bytes, _35$$6, _37$$6 TSRMLS_CC);
zephir_array_fetch_string(&_40$$6, value, SL("size"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 173 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_35$$6, "floatval", &_36, 328, _40$$6);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&_41$$6, "floatval", &_36, 328, bytes);
zephir_check_call_status();
if (ZEPHIR_GT(_35$$6, _41$$6)) {
ZEPHIR_INIT_VAR(_42$$9);
ZVAL_STRING(_42$$9, "FileSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_43$$9);
ZVAL_STRING(_43$$9, "messageSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, _42$$9, _43$$9);
zephir_check_temp_parameter(_42$$9);
zephir_check_temp_parameter(_43$$9);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_42$$9);
object_init_ex(_42$$9, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_44$$9, "strtr", &_11, 27, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_43$$9);
ZVAL_STRING(_43$$9, "FileSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _42$$9, "__construct", &_12, 475, _44$$9, field, _43$$9, code);
zephir_check_temp_parameter(_43$$9);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _42$$9);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
ZEPHIR_INIT_NVAR(_28);
ZVAL_STRING(_28, "allowedTypes", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_45, this_ptr, "hasoption", NULL, 0, _28);
zephir_check_temp_parameter(_28);
zephir_check_call_status();
if (zephir_is_true(_45)) {
ZEPHIR_INIT_VAR(_46$$10);
ZVAL_STRING(_46$$10, "allowedTypes", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&types, this_ptr, "getoption", NULL, 0, _46$$10);
zephir_check_temp_parameter(_46$$10);
zephir_check_call_status();
ZEPHIR_OBS_VAR(fieldTypes);
if (zephir_array_isset_fetch(&fieldTypes, types, field, 0 TSRMLS_CC)) {
ZEPHIR_CPY_WRT(types, fieldTypes);
}
if (Z_TYPE_P(types) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Option 'allowedTypes' must be an array", "phalcon/validation/validator/file.zep", 198);
return;
}
if ((zephir_function_exists_ex(SS("finfo_open") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_SINIT_VAR(_47$$13);
ZVAL_LONG(&_47$$13, 16);
ZEPHIR_CALL_FUNCTION(&tmp, "finfo_open", NULL, 250, &_47$$13);
zephir_check_call_status();
zephir_array_fetch_string(&_48$$13, value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 203 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&mime, "finfo_file", NULL, 251, tmp, _48$$13);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(NULL, "finfo_close", NULL, 252, tmp);
zephir_check_call_status();
} else {
ZEPHIR_OBS_NVAR(mime);
zephir_array_fetch_string(&mime, value, SL("type"), PH_NOISY, "phalcon/validation/validator/file.zep", 207 TSRMLS_CC);
}
if (!(zephir_fast_in_array(mime, types TSRMLS_CC))) {
ZEPHIR_INIT_VAR(_49$$15);
ZVAL_STRING(_49$$15, "FileType", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_50$$15);
ZVAL_STRING(_50$$15, "messageType", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, _49$$15, _50$$15);
zephir_check_temp_parameter(_49$$15);
zephir_check_temp_parameter(_50$$15);
zephir_check_call_status();
ZEPHIR_INIT_VAR(replacePairs);
zephir_create_array(replacePairs, 2, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_49$$15);
zephir_fast_join_str(_49$$15, SL(", "), types TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":types"), &_49$$15, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_49$$15);
object_init_ex(_49$$15, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_51$$15, "strtr", &_11, 27, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_50$$15);
ZVAL_STRING(_50$$15, "FileType", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _49$$15, "__construct", &_12, 475, _51$$15, field, _50$$15, code);
zephir_check_temp_parameter(_50$$15);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _49$$15);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
ZEPHIR_INIT_NVAR(_28);
ZVAL_STRING(_28, "minResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_52, this_ptr, "hasoption", NULL, 0, _28);
zephir_check_temp_parameter(_28);
zephir_check_call_status();
_53 = zephir_is_true(_52);
if (!(_53)) {
ZEPHIR_INIT_NVAR(_28);
ZVAL_STRING(_28, "maxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_54, this_ptr, "hasoption", NULL, 0, _28);
zephir_check_temp_parameter(_28);
zephir_check_call_status();
_53 = zephir_is_true(_54);
}
if (_53) {
zephir_array_fetch_string(&_55$$16, value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 228 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&tmp, "getimagesize", NULL, 261, _55$$16);
zephir_check_call_status();
ZEPHIR_OBS_VAR(width);
zephir_array_fetch_long(&width, tmp, 0, PH_NOISY, "phalcon/validation/validator/file.zep", 229 TSRMLS_CC);
ZEPHIR_OBS_VAR(height);
zephir_array_fetch_long(&height, tmp, 1, PH_NOISY, "phalcon/validation/validator/file.zep", 230 TSRMLS_CC);
ZEPHIR_INIT_VAR(_57$$16);
ZVAL_STRING(_57$$16, "minResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_56$$16, this_ptr, "hasoption", NULL, 0, _57$$16);
zephir_check_temp_parameter(_57$$16);
zephir_check_call_status();
if (zephir_is_true(_56$$16)) {
ZEPHIR_INIT_VAR(_58$$17);
ZVAL_STRING(_58$$17, "minResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&minResolution, this_ptr, "getoption", NULL, 0, _58$$17);
zephir_check_temp_parameter(_58$$17);
zephir_check_call_status();
if (Z_TYPE_P(minResolution) == IS_ARRAY) {
zephir_array_fetch(&_59$$18, minResolution, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 235 TSRMLS_CC);
ZEPHIR_CPY_WRT(minResolution, _59$$18);
}
ZEPHIR_INIT_VAR(minResolutionArray);
zephir_fast_explode_str(minResolutionArray, SL("x"), minResolution, LONG_MAX TSRMLS_CC);
ZEPHIR_OBS_VAR(minWidth);
zephir_array_fetch_long(&minWidth, minResolutionArray, 0, PH_NOISY, "phalcon/validation/validator/file.zep", 238 TSRMLS_CC);
ZEPHIR_OBS_VAR(minHeight);
zephir_array_fetch_long(&minHeight, minResolutionArray, 1, PH_NOISY, "phalcon/validation/validator/file.zep", 239 TSRMLS_CC);
} else {
ZEPHIR_INIT_NVAR(minWidth);
ZVAL_LONG(minWidth, 1);
ZEPHIR_INIT_NVAR(minHeight);
ZVAL_LONG(minHeight, 1);
}
_60$$16 = ZEPHIR_LT(width, minWidth);
if (!(_60$$16)) {
_60$$16 = ZEPHIR_LT(height, minHeight);
}
if (_60$$16) {
ZEPHIR_INIT_VAR(_61$$20);
ZVAL_STRING(_61$$20, "FileMinResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_62$$20);
ZVAL_STRING(_62$$20, "messageMinResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, _61$$20, _62$$20);
zephir_check_temp_parameter(_61$$20);
zephir_check_temp_parameter(_62$$20);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(replacePairs);
zephir_create_array(replacePairs, 2, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&replacePairs, SL(":min"), &minResolution, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_61$$20);
object_init_ex(_61$$20, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_63$$20, "strtr", &_11, 27, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_62$$20);
ZVAL_STRING(_62$$20, "FileMinResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _61$$20, "__construct", &_12, 475, _63$$20, field, _62$$20, code);
zephir_check_temp_parameter(_62$$20);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _61$$20);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_NVAR(_57$$16);
ZVAL_STRING(_57$$16, "maxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_64$$16, this_ptr, "hasoption", NULL, 0, _57$$16);
zephir_check_temp_parameter(_57$$16);
zephir_check_call_status();
if (zephir_is_true(_64$$16)) {
ZEPHIR_INIT_VAR(_65$$21);
ZVAL_STRING(_65$$21, "maxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&maxResolution, this_ptr, "getoption", NULL, 0, _65$$21);
zephir_check_temp_parameter(_65$$21);
zephir_check_call_status();
if (Z_TYPE_P(maxResolution) == IS_ARRAY) {
zephir_array_fetch(&_66$$22, maxResolution, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 265 TSRMLS_CC);
ZEPHIR_CPY_WRT(maxResolution, _66$$22);
}
ZEPHIR_INIT_VAR(maxResolutionArray);
zephir_fast_explode_str(maxResolutionArray, SL("x"), maxResolution, LONG_MAX TSRMLS_CC);
ZEPHIR_OBS_VAR(maxWidth);
zephir_array_fetch_long(&maxWidth, maxResolutionArray, 0, PH_NOISY, "phalcon/validation/validator/file.zep", 268 TSRMLS_CC);
ZEPHIR_OBS_VAR(maxHeight);
zephir_array_fetch_long(&maxHeight, maxResolutionArray, 1, PH_NOISY, "phalcon/validation/validator/file.zep", 269 TSRMLS_CC);
_67$$21 = ZEPHIR_GT(width, maxWidth);
if (!(_67$$21)) {
_67$$21 = ZEPHIR_GT(height, maxHeight);
}
if (_67$$21) {
ZEPHIR_INIT_VAR(_68$$23);
ZVAL_STRING(_68$$23, "FileMaxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_69$$23);
ZVAL_STRING(_69$$23, "messageMaxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, _68$$23, _69$$23);
zephir_check_temp_parameter(_68$$23);
zephir_check_temp_parameter(_69$$23);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(replacePairs);
zephir_create_array(replacePairs, 2, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&replacePairs, SL(":max"), &maxResolution, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_68$$23);
object_init_ex(_68$$23, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_70$$23, "strtr", &_11, 27, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_69$$23);
ZVAL_STRING(_69$$23, "FileMaxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _68$$23, "__construct", &_12, 475, _70$$23, field, _69$$23, code);
zephir_check_temp_parameter(_69$$23);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _68$$23);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
}
RETURN_MM_BOOL(1);
}
/**
* Returns a slice of the resultset to show in the pagination
*/
PHP_METHOD(Phalcon_Paginator_Adapter_QueryBuilder, getPaginate) {
zval *_6$$14, *_8$$15;
zend_bool hasHaving = 0, hasGroup = 0, _2;
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, *sql = NULL, *columns = NULL, *db = NULL, *_0, *_1 = NULL, *groups = NULL, *_10, *_22, *_3$$10, *groupColumn$$11 = NULL, *_4$$14 = NULL, *_5$$14, *_7$$14, *_9$$15, *_11$$16 = NULL, *_12$$16 = NULL, *_13$$16, *_14$$16, *_15$$16, *_16$$16, _17$$16, _18$$16, *_19$$17, _20$$17, _21$$17;
zend_long 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_OBS_VAR(columns);
zephir_read_property_this(&columns, this_ptr, SL("_columns"), 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_CALL_METHOD(&_1, totalBuilder, "gethaving", NULL, 0);
zephir_check_call_status();
hasHaving = !(ZEPHIR_IS_EMPTY(_1));
ZEPHIR_CALL_METHOD(&groups, totalBuilder, "getgroupby", NULL, 0);
zephir_check_call_status();
hasGroup = !(ZEPHIR_IS_EMPTY(groups));
_2 = hasHaving;
if (_2) {
_2 = !hasGroup;
}
if (_2) {
if (ZEPHIR_IS_EMPTY(columns)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_paginator_exception_ce, "When having is set there should be columns option provided for which calculate row count", "phalcon/paginator/adapter/querybuilder.zep", 186);
return;
}
ZEPHIR_CALL_METHOD(NULL, totalBuilder, "columns", NULL, 0, columns);
zephir_check_call_status();
} else {
ZEPHIR_INIT_VAR(_3$$10);
ZVAL_STRING(_3$$10, "COUNT(*) [rowcount]", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, totalBuilder, "columns", NULL, 0, _3$$10);
zephir_check_temp_parameter(_3$$10);
zephir_check_call_status();
}
if (hasGroup) {
if (Z_TYPE_P(groups) == IS_ARRAY) {
ZEPHIR_INIT_VAR(groupColumn$$11);
zephir_fast_join_str(groupColumn$$11, SL(", "), groups TSRMLS_CC);
} else {
ZEPHIR_CPY_WRT(groupColumn$$11, groups);
}
if (!(hasHaving)) {
ZEPHIR_INIT_VAR(_5$$14);
ZVAL_NULL(_5$$14);
ZEPHIR_CALL_METHOD(&_4$$14, totalBuilder, "groupby", NULL, 0, _5$$14);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_6$$14);
zephir_create_array(_6$$14, 1, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_7$$14);
ZEPHIR_CONCAT_SVS(_7$$14, "COUNT(DISTINCT ", groupColumn$$11, ") AS rowcount");
zephir_array_fast_append(_6$$14, _7$$14);
ZEPHIR_CALL_METHOD(NULL, _4$$14, "columns", NULL, 0, _6$$14);
zephir_check_call_status();
} else {
ZEPHIR_INIT_VAR(_8$$15);
zephir_create_array(_8$$15, 1, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_9$$15);
ZEPHIR_CONCAT_SV(_9$$15, "DISTINCT ", groupColumn$$11);
zephir_array_fast_append(_8$$15, _9$$15);
ZEPHIR_CALL_METHOD(NULL, totalBuilder, "columns", NULL, 0, _8$$15);
zephir_check_call_status();
}
}
ZEPHIR_INIT_VAR(_10);
ZVAL_NULL(_10);
ZEPHIR_CALL_METHOD(NULL, totalBuilder, "orderby", NULL, 0, _10);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&totalQuery, totalBuilder, "getquery", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(rowcount);
if (hasHaving) {
ZEPHIR_CALL_METHOD(&sql, totalQuery, "getsql", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_11$$16, totalBuilder, "getdi", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_12$$16);
ZVAL_STRING(_12$$16, "db", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&db, _11$$16, "get", NULL, 0, _12$$16);
zephir_check_temp_parameter(_12$$16);
zephir_check_call_status();
zephir_array_fetch_string(&_13$$16, sql, SL("sql"), PH_NOISY | PH_READONLY, "phalcon/paginator/adapter/querybuilder.zep", 228 TSRMLS_CC);
ZEPHIR_INIT_VAR(_14$$16);
ZEPHIR_CONCAT_SVS(_14$$16, "SELECT COUNT(*) as rowcount FROM (", _13$$16, ") as T1");
zephir_array_fetch_string(&_15$$16, sql, SL("bind"), PH_NOISY | PH_READONLY, "phalcon/paginator/adapter/querybuilder.zep", 228 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_12$$16);
ZVAL_LONG(_12$$16, 2);
ZEPHIR_CALL_METHOD(&row, db, "fetchone", NULL, 0, _14$$16, _12$$16, _15$$16);
zephir_check_call_status();
if (zephir_is_true(row)) {
zephir_array_fetch_string(&_16$$16, row, SL("rowcount"), PH_NOISY | PH_READONLY, "phalcon/paginator/adapter/querybuilder.zep", 229 TSRMLS_CC);
ZVAL_LONG(rowcount, zephir_get_intval(_16$$16));
} else {
ZVAL_LONG(rowcount, 0);
}
ZEPHIR_SINIT_VAR(_17$$16);
div_function(&_17$$16, rowcount, limit TSRMLS_CC);
ZEPHIR_SINIT_VAR(_18$$16);
ZVAL_DOUBLE(&_18$$16, zephir_ceil(&_17$$16 TSRMLS_CC));
ZEPHIR_INIT_VAR(totalPages);
ZVAL_LONG(totalPages, zephir_get_intval(&_18$$16));
} else {
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(_19$$17);
zephir_read_property(&_19$$17, row, SL("rowcount"), PH_NOISY_CC);
ZEPHIR_INIT_NVAR(rowcount);
ZVAL_LONG(rowcount, zephir_get_intval(_19$$17));
} else {
ZEPHIR_INIT_NVAR(rowcount);
ZVAL_LONG(rowcount, 0);
}
ZEPHIR_SINIT_VAR(_20$$17);
div_function(&_20$$17, rowcount, limit TSRMLS_CC);
ZEPHIR_SINIT_VAR(_21$$17);
ZVAL_DOUBLE(&_21$$17, zephir_ceil(&_20$$17 TSRMLS_CC));
ZEPHIR_INIT_NVAR(totalPages);
ZVAL_LONG(totalPages, zephir_get_intval(&_21$$17));
}
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(_22);
ZVAL_LONG(_22, 1);
zephir_update_property_zval(page, SL("first"), _22 TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_22);
ZVAL_LONG(_22, before);
zephir_update_property_zval(page, SL("before"), _22 TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_22);
ZVAL_LONG(_22, numberPage);
zephir_update_property_zval(page, SL("current"), _22 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);
_22 = zephir_fetch_nproperty_this(this_ptr, SL("_limitRows"), PH_NOISY_CC);
zephir_update_property_zval(page, SL("limit"), _22 TSRMLS_CC);
RETURN_CCTOR(page);
}
/**
* Changes internal pointer to a specific position in the resultset
* Set new position if required and set this->_row
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset, seek) {
zend_bool _1, _7$$3;
zephir_fcall_cache_entry *_16 = NULL;
zval *position_param = NULL, *result = NULL, *row = NULL, *_0, *_2, *_3$$3, *_6$$3, *_8$$3, *_10$$3, *_14$$3, *_17$$3, *_4$$4, *_5$$4, *_9$$6 = NULL, *_11$$7, *_12$$7 = NULL, *_13$$7, *_15$$8 = NULL;
int position, ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &position_param);
position = zephir_get_intval(position_param);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_pointer"), PH_NOISY_CC);
_1 = !ZEPHIR_IS_LONG(_0, position);
if (!(_1)) {
_2 = zephir_fetch_nproperty_this(this_ptr, SL("_row"), PH_NOISY_CC);
_1 = Z_TYPE_P(_2) == IS_NULL;
}
if (_1) {
ZEPHIR_OBS_VAR(_3$$3);
zephir_read_property_this(&_3$$3, this_ptr, SL("_rows"), PH_NOISY_CC);
if (Z_TYPE_P(_3$$3) == IS_ARRAY) {
ZEPHIR_OBS_VAR(row);
_4$$4 = zephir_fetch_nproperty_this(this_ptr, SL("_rows"), PH_NOISY_CC);
if (zephir_array_isset_long_fetch(&row, _4$$4, position, 0 TSRMLS_CC)) {
zephir_update_property_this(this_ptr, SL("_row"), row TSRMLS_CC);
}
ZEPHIR_INIT_ZVAL_NREF(_5$$4);
ZVAL_LONG(_5$$4, position);
zephir_update_property_this(this_ptr, SL("_pointer"), _5$$4 TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_activeRow"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC);
RETURN_MM_NULL();
}
ZEPHIR_OBS_VAR(result);
zephir_read_property_this(&result, this_ptr, SL("_result"), PH_NOISY_CC);
_6$$3 = zephir_fetch_nproperty_this(this_ptr, SL("_row"), PH_NOISY_CC);
_7$$3 = Z_TYPE_P(_6$$3) == IS_NULL;
if (_7$$3) {
_8$$3 = zephir_fetch_nproperty_this(this_ptr, SL("_pointer"), PH_NOISY_CC);
_7$$3 = ZEPHIR_IS_LONG_IDENTICAL(_8$$3, 0);
}
if (_7$$3) {
ZEPHIR_CALL_METHOD(&_9$$6, result, "fetch", NULL, 0);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_row"), _9$$6 TSRMLS_CC);
}
_10$$3 = zephir_fetch_nproperty_this(this_ptr, SL("_pointer"), PH_NOISY_CC);
if (ZEPHIR_GT_LONG(_10$$3, position)) {
ZEPHIR_INIT_VAR(_11$$7);
ZVAL_LONG(_11$$7, position);
ZEPHIR_CALL_METHOD(NULL, result, "dataseek", NULL, 0, _11$$7);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_12$$7, result, "fetch", NULL, 0);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_row"), _12$$7 TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_13$$7);
ZVAL_LONG(_13$$7, position);
zephir_update_property_this(this_ptr, SL("_pointer"), _13$$7 TSRMLS_CC);
}
while (1) {
_14$$3 = zephir_fetch_nproperty_this(this_ptr, SL("_pointer"), PH_NOISY_CC);
if (!(ZEPHIR_LT_LONG(_14$$3, position))) {
break;
}
ZEPHIR_CALL_METHOD(&_15$$8, result, "fetch", &_16, 0);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_row"), _15$$8 TSRMLS_CC);
RETURN_ON_FAILURE(zephir_property_incr(this_ptr, SL("_pointer") TSRMLS_CC));
}
ZEPHIR_INIT_ZVAL_NREF(_17$$3);
ZVAL_LONG(_17$$3, position);
zephir_update_property_this(this_ptr, SL("_pointer"), _17$$3 TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_activeRow"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC);
}
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Monapi_Image_ResizeOptions_Auto, getSizeByAuto) {
zval *width_param = NULL, *height_param = NULL, *original_width_param = NULL, *original_height_param = NULL, *optimal_width = NULL, *optimal_height = NULL, *_0 = NULL, *_1 = NULL, *_2 = NULL, *sizes;
int width, height, original_width, original_height, ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 4, 0, &width_param, &height_param, &original_width_param, &original_height_param);
width = zephir_get_intval(width_param);
height = zephir_get_intval(height_param);
original_width = zephir_get_intval(original_width_param);
original_height = zephir_get_intval(original_height_param);
if (original_height < original_width) {
ZEPHIR_INIT_VAR(optimal_width);
ZVAL_LONG(optimal_width, width);
ZEPHIR_INIT_VAR(_0);
ZVAL_LONG(_0, original_width);
ZEPHIR_INIT_VAR(_1);
ZVAL_LONG(_1, original_height);
ZEPHIR_CALL_SELF(&optimal_height, "getsizebyfixedwidth", NULL, optimal_width, _0, _1);
zephir_check_call_status();
if (ZEPHIR_GT_LONG(optimal_height, height)) {
ZEPHIR_INIT_NVAR(optimal_height);
ZVAL_LONG(optimal_height, height);
ZEPHIR_INIT_NVAR(_0);
ZVAL_LONG(_0, original_width);
ZEPHIR_INIT_NVAR(_1);
ZVAL_LONG(_1, original_height);
ZEPHIR_CALL_SELF(&optimal_width, "getsizebyfixedheight", NULL, optimal_height, _0, _1);
zephir_check_call_status();
}
} else if (original_height > original_width) {
ZEPHIR_INIT_NVAR(_0);
ZVAL_LONG(_0, height);
ZEPHIR_INIT_NVAR(_1);
ZVAL_LONG(_1, original_width);
ZEPHIR_INIT_VAR(_2);
ZVAL_LONG(_2, original_height);
ZEPHIR_CALL_SELF(&optimal_width, "getsizebyfixedheight", NULL, _0, _1, _2);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(optimal_height);
ZVAL_LONG(optimal_height, height);
if (ZEPHIR_GT_LONG(optimal_width, width)) {
ZEPHIR_INIT_NVAR(optimal_width);
ZVAL_LONG(optimal_width, width);
ZEPHIR_INIT_NVAR(_0);
ZVAL_LONG(_0, original_width);
ZEPHIR_INIT_NVAR(_1);
ZVAL_LONG(_1, original_height);
ZEPHIR_CALL_SELF(&optimal_height, "getsizebyfixedwidth", NULL, optimal_width, _0, _1);
zephir_check_call_status();
}
} else {
if (height > width) {
ZEPHIR_INIT_NVAR(optimal_width);
ZVAL_LONG(optimal_width, width);
ZEPHIR_INIT_NVAR(_0);
ZVAL_LONG(_0, width);
ZEPHIR_INIT_NVAR(_1);
ZVAL_LONG(_1, original_width);
ZEPHIR_INIT_NVAR(_2);
ZVAL_LONG(_2, original_height);
ZEPHIR_CALL_SELF(&optimal_height, "getsizebyfixedwidth", NULL, _0, _1, _2);
zephir_check_call_status();
} else if (height < width) {
ZEPHIR_INIT_NVAR(_0);
ZVAL_LONG(_0, height);
ZEPHIR_INIT_NVAR(_1);
ZVAL_LONG(_1, original_width);
ZEPHIR_INIT_NVAR(_2);
ZVAL_LONG(_2, original_height);
ZEPHIR_CALL_SELF(&optimal_width, "getsizebyfixedheight", NULL, _0, _1, _2);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(optimal_height);
ZVAL_LONG(optimal_height, height);
} else {
ZEPHIR_INIT_NVAR(optimal_width);
ZVAL_LONG(optimal_width, width);
ZEPHIR_INIT_NVAR(optimal_height);
ZVAL_LONG(optimal_height, height);
}
}
ZEPHIR_INIT_VAR(sizes);
array_init_size(sizes, 3);
zephir_array_update_string(&sizes, SL("optimal_width"), &optimal_width, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&sizes, SL("optimal_height"), &optimal_height, PH_COPY | PH_SEPARATE);
RETURN_CCTOR(sizes);
}
PHP_METHOD(PhalconPlus_Db_Mysql, getConnection) {
zephir_nts_static zephir_fcall_cache_entry *_4 = NULL, *_7 = NULL;
zephir_fcall_cache_entry *_1 = NULL;
int ZEPHIR_LAST_CALL_STATUS, _5;
zval *connection = NULL, *tryTimes = NULL, *e = NULL, *_0, *_2 = NULL, *_3 = NULL, _6 = zval_used_for_init;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(connection);
ZVAL_NULL(connection);
ZEPHIR_INIT_VAR(tryTimes);
ZVAL_LONG(tryTimes, 5);
while (1) {
if (!(!(Z_TYPE_P(connection) == IS_OBJECT))) {
break;
}
/* try_start_1: */
ZEPHIR_INIT_NVAR(connection);
object_init_ex(connection, zephir_get_internal_ce(SS("phalcon\\db\\adapter\\pdo\\mysql") TSRMLS_CC));
_0 = zephir_fetch_nproperty_this(this_ptr, SL("descriptor"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, connection, "__construct", &_1, _0);
zephir_check_call_status_or_jump(try_end_1);
try_end_1:
if (EG(exception)) {
ZEPHIR_CPY_WRT(e, EG(exception));
if (zephir_is_instance_of(e, SL("PhalconPlus\\Db\\Exception") TSRMLS_CC)) {
zend_clear_exception(TSRMLS_C);
ZEPHIR_INIT_NVAR(_2);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("descriptor"), PH_NOISY_CC);
zephir_json_encode(_2, &(_2), _0, 0 TSRMLS_CC);
ZEPHIR_INIT_LNVAR(_3);
ZEPHIR_CONCAT_SV(_3, "PHP Fatal error: PhalconPlus::Db::MySQL::connect() failed to connect to MySQL. Detail: ", _2);
ZEPHIR_CALL_FUNCTION(NULL, "error_log", &_4, _3);
zephir_check_call_status();
_5 = (zephir_get_numberval(tryTimes) - 1);
ZEPHIR_INIT_NVAR(tryTimes);
ZVAL_LONG(tryTimes, _5);
if (ZEPHIR_GT_LONG(tryTimes, 0)) {
ZEPHIR_SINIT_NVAR(_6);
ZVAL_LONG(&_6, 100000);
ZEPHIR_CALL_FUNCTION(NULL, "usleep", &_7, &_6);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_6);
ZVAL_STRING(&_6, "PHP Notice: PhalconPlus::Db::MySQL::connnect() retry to connect to MySQL for the time ... ", 0);
ZEPHIR_CALL_FUNCTION(NULL, "error_log", &_4, &_6);
zephir_check_call_status();
} else {
ZEPHIR_SINIT_NVAR(_6);
ZVAL_STRING(&_6, "PHP Fatal error: PhalconPlus::Db::MySQL::connect() finally failed to connect to MySQL", 0);
ZEPHIR_CALL_FUNCTION(NULL, "error_log", &_4, &_6);
zephir_check_call_status();
zephir_throw_exception_debug(e, "phalconplus/Db/Mysql.zep", 52 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
}
}
}
RETURN_CCTOR(connection);
}