/**
* Renders a view using the template engine
*/
PHP_METHOD(Phalcon_Mvc_View_Engine_Volt, render) {
HashTable *_1$$4;
HashPosition _0$$4;
int ZEPHIR_LAST_CALL_STATUS;
zend_bool mustClean;
zval *templatePath_param = NULL, *params, *mustClean_param = NULL, *compiler = NULL, *compiledTemplatePath = NULL, *key = NULL, *value = NULL, **_2$$4, *_3$$5 = NULL, *_4$$6, *_5$$6 = NULL;
zval *templatePath = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 1, &templatePath_param, ¶ms, &mustClean_param);
if (unlikely(Z_TYPE_P(templatePath_param) != IS_STRING && Z_TYPE_P(templatePath_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'templatePath' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(templatePath_param) == IS_STRING)) {
zephir_get_strval(templatePath, templatePath_param);
} else {
ZEPHIR_INIT_VAR(templatePath);
ZVAL_EMPTY_STRING(templatePath);
}
if (!mustClean_param) {
mustClean = 0;
} else {
mustClean = zephir_get_boolval(mustClean_param);
}
if (mustClean) {
ZEPHIR_CALL_FUNCTION(NULL, "ob_clean", NULL, 366);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(&compiler, this_ptr, "getcompiler", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, compiler, "compile", NULL, 0, templatePath);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&compiledTemplatePath, compiler, "getcompiledtemplatepath", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(params) == IS_ARRAY) {
zephir_is_iterable(params, &_1$$4, &_0$$4, 0, 0, "phalcon/mvc/view/engine/volt.zep", 118);
for (
; zephir_hash_get_current_data_ex(_1$$4, (void**) &_2$$4, &_0$$4) == SUCCESS
; zephir_hash_move_forward_ex(_1$$4, &_0$$4)
) {
ZEPHIR_GET_HMKEY(key, _1$$4, _0$$4);
ZEPHIR_GET_HVALUE(value, _2$$4);
ZEPHIR_CPY_WRT(_3$$5, value);
if (zephir_set_symbol(key, _3$$5 TSRMLS_CC) == FAILURE){
return;
}
}
}
if (zephir_require_zval(compiledTemplatePath TSRMLS_CC) == FAILURE) {
RETURN_MM_NULL();
}
if (mustClean) {
_4$$6 = zephir_fetch_nproperty_this(this_ptr, SL("_view"), PH_NOISY_CC);
ZEPHIR_CALL_FUNCTION(&_5$$6, "ob_get_contents", NULL, 118);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, _4$$6, "setcontent", NULL, 0, _5$$6);
zephir_check_call_status();
}
ZEPHIR_MM_RESTORE();
}
/**
* Phalcon\Db\Reference constructor
*/
PHP_METHOD(Phalcon_Db_Reference, __construct) {
zval *definition = NULL;
zval *name_param = NULL, *definition_param = NULL, *columns = NULL, *schema = NULL, *referencedTable = NULL, *referencedSchema = NULL, *referencedColumns = NULL, *onDelete = NULL, *onUpdate = NULL;
zval *name = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &name_param, &definition_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);
}
definition = definition_param;
zephir_update_property_this(getThis(), SL("_name"), name TSRMLS_CC);
ZEPHIR_OBS_VAR(referencedTable);
if (zephir_array_isset_string_fetch(&referencedTable, definition, SS("referencedTable"), 0 TSRMLS_CC)) {
zephir_update_property_this(getThis(), SL("_referencedTable"), referencedTable TSRMLS_CC);
} else {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "Referenced table is required", "phalcon/db/reference.zep", 108);
return;
}
ZEPHIR_OBS_VAR(columns);
if (zephir_array_isset_string_fetch(&columns, definition, SS("columns"), 0 TSRMLS_CC)) {
zephir_update_property_this(getThis(), SL("_columns"), columns TSRMLS_CC);
} else {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "Foreign key columns are required", "phalcon/db/reference.zep", 114);
return;
}
ZEPHIR_OBS_VAR(referencedColumns);
if (zephir_array_isset_string_fetch(&referencedColumns, definition, SS("referencedColumns"), 0 TSRMLS_CC)) {
zephir_update_property_this(getThis(), SL("_referencedColumns"), referencedColumns TSRMLS_CC);
} else {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "Referenced columns of the foreign key are required", "phalcon/db/reference.zep", 120);
return;
}
ZEPHIR_OBS_VAR(schema);
if (zephir_array_isset_string_fetch(&schema, definition, SS("schema"), 0 TSRMLS_CC)) {
zephir_update_property_this(getThis(), SL("_schemaName"), schema TSRMLS_CC);
}
ZEPHIR_OBS_VAR(referencedSchema);
if (zephir_array_isset_string_fetch(&referencedSchema, definition, SS("referencedSchema"), 0 TSRMLS_CC)) {
zephir_update_property_this(getThis(), SL("_referencedSchema"), referencedSchema TSRMLS_CC);
}
ZEPHIR_OBS_VAR(onDelete);
if (zephir_array_isset_string_fetch(&onDelete, definition, SS("onDelete"), 0 TSRMLS_CC)) {
zephir_update_property_this(getThis(), SL("_onDelete"), onDelete TSRMLS_CC);
}
ZEPHIR_OBS_VAR(onUpdate);
if (zephir_array_isset_string_fetch(&onUpdate, definition, SS("onUpdate"), 0 TSRMLS_CC)) {
zephir_update_property_this(getThis(), SL("_onUpdate"), onUpdate TSRMLS_CC);
}
if (zephir_fast_count_int(columns TSRMLS_CC) != zephir_fast_count_int(referencedColumns TSRMLS_CC)) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "Number of columns is not equals than the number of columns referenced", "phalcon/db/reference.zep", 140);
return;
}
ZEPHIR_MM_RESTORE();
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_ExclusionIn, validate) {
int ZEPHIR_LAST_CALL_STATUS;
zval *field = NULL;
zval *validation, *field_param = NULL, *value = NULL, *domain = NULL, *message = NULL, *label = NULL, *replacePairs = NULL, *strict = NULL, *fieldDomain = NULL, *code = NULL, *_0 = NULL, *_1 = NULL, *_4 = NULL, *_2$$6, *_3$$7, *_5$$9 = NULL, *_10$$9 = NULL, *_11$$9, *_6$$10, *_7$$12, *_8$$13, *_9$$14;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &validation, &field_param);
if (unlikely(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 (likely(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_INIT_VAR(_0);
ZVAL_STRING(_0, "domain", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&domain, this_ptr, "getoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
ZEPHIR_OBS_VAR(fieldDomain);
if (zephir_array_isset_fetch(&fieldDomain, domain, field, 0 TSRMLS_CC)) {
if (Z_TYPE_P(fieldDomain) == IS_ARRAY) {
ZEPHIR_CPY_WRT(domain, fieldDomain);
}
}
if (Z_TYPE_P(domain) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Option 'domain' must be an array", "phalcon/validation/validator/exclusionin.zep", 74);
return;
}
ZEPHIR_INIT_VAR(strict);
ZVAL_BOOL(strict, 0);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "strict", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_1, this_ptr, "hasoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (zephir_is_true(_1)) {
ZEPHIR_INIT_VAR(_2$$6);
ZVAL_STRING(_2$$6, "strict", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&strict, this_ptr, "getoption", NULL, 0, _2$$6);
zephir_check_temp_parameter(_2$$6);
zephir_check_call_status();
if (Z_TYPE_P(strict) == IS_ARRAY) {
zephir_array_fetch(&_3$$7, strict, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/exclusionin.zep", 83 TSRMLS_CC);
ZEPHIR_CPY_WRT(strict, _3$$7);
}
if (Z_TYPE_P(strict) != IS_BOOL) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Option 'strict' must be a boolean", "phalcon/validation/validator/exclusionin.zep", 87);
return;
}
}
ZEPHIR_CALL_FUNCTION(&_4, "in_array", NULL, 377, value, domain, strict);
zephir_check_call_status();
if (zephir_is_true(_4)) {
ZEPHIR_INIT_VAR(_5$$9);
ZVAL_STRING(_5$$9, "label", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&label, this_ptr, "getoption", NULL, 0, _5$$9);
zephir_check_temp_parameter(_5$$9);
zephir_check_call_status();
if (Z_TYPE_P(label) == IS_ARRAY) {
zephir_array_fetch(&_6$$10, label, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/exclusionin.zep", 98 TSRMLS_CC);
ZEPHIR_CPY_WRT(label, _6$$10);
}
if (ZEPHIR_IS_EMPTY(label)) {
ZEPHIR_CALL_METHOD(&label, validation, "getlabel", NULL, 0, field);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_5$$9);
ZVAL_STRING(_5$$9, "message", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _5$$9);
zephir_check_temp_parameter(_5$$9);
zephir_check_call_status();
if (Z_TYPE_P(message) == IS_ARRAY) {
zephir_array_fetch(&_7$$12, message, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/exclusionin.zep", 106 TSRMLS_CC);
ZEPHIR_CPY_WRT(message, _7$$12);
}
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(_5$$9);
zephir_fast_join_str(_5$$9, SL(", "), domain TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":domain"), &_5$$9, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_VAR(_8$$13);
ZVAL_STRING(_8$$13, "ExclusionIn", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _8$$13);
zephir_check_temp_parameter(_8$$13);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_5$$9);
ZVAL_STRING(_5$$9, "code", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&code, this_ptr, "getoption", NULL, 0, _5$$9);
zephir_check_temp_parameter(_5$$9);
zephir_check_call_status();
if (Z_TYPE_P(code) == IS_ARRAY) {
zephir_array_fetch(&_9$$14, code, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/exclusionin.zep", 115 TSRMLS_CC);
ZEPHIR_CPY_WRT(code, _9$$14);
}
ZEPHIR_INIT_NVAR(_5$$9);
object_init_ex(_5$$9, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_10$$9, "strtr", NULL, 26, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_11$$9);
ZVAL_STRING(_11$$9, "ExclusionIn", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _5$$9, "__construct", NULL, 462, _10$$9, field, _11$$9, code);
zephir_check_temp_parameter(_11$$9);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _5$$9);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_InclusionIn, validate) {
zend_bool _2;
int ZEPHIR_LAST_CALL_STATUS;
zval *field = NULL;
zval *validation, *field_param = NULL, *value = NULL, *domain = NULL, *message = NULL, *label = NULL, *replacePairs, *strict = NULL, *_0 = NULL, *_1 = NULL, *_3 = NULL, *_4 = NULL, *_5 = NULL, *_6;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &validation, &field_param);
if (unlikely(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 (likely(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_INIT_VAR(_1);
ZVAL_STRING(_1, "allowEmpty", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "issetoption", NULL, 0, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
_2 = zephir_is_true(_0);
if (_2) {
_2 = ZEPHIR_IS_EMPTY(value);
}
if (_2) {
RETURN_MM_BOOL(1);
}
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "domain", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&domain, this_ptr, "getoption", NULL, 0, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
if (Z_TYPE_P(domain) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Option 'domain' must be an array", "phalcon/validation/validator/inclusionin.zep", 62);
return;
}
ZEPHIR_INIT_VAR(strict);
ZVAL_BOOL(strict, 0);
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "strict", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_3, this_ptr, "issetoption", NULL, 0, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
if (zephir_is_true(_3)) {
if (Z_TYPE_P(strict) != IS_BOOL) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Option 'strict' must be a boolean", "phalcon/validation/validator/inclusionin.zep", 68);
return;
}
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "strict", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&strict, this_ptr, "getoption", NULL, 0, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
}
ZEPHIR_CALL_FUNCTION(&_4, "in_array", NULL, 365, value, domain, strict);
zephir_check_call_status();
if (!(zephir_is_true(_4))) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "label", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&label, this_ptr, "getoption", NULL, 0, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
if (ZEPHIR_IS_EMPTY(label)) {
ZEPHIR_CALL_METHOD(&label, validation, "getlabel", NULL, 0, field);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "message", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _1);
zephir_check_temp_parameter(_1);
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(_1);
zephir_fast_join_str(_1, SL(", "), domain TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":domain"), &_1, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "InclusionIn", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_1);
object_init_ex(_1, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_5, "strtr", NULL, 53, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_6);
ZVAL_STRING(_6, "InclusionIn", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, 436, _5, field, _6);
zephir_check_temp_parameter(_6);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _1);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_Between, validate) {
zend_bool _2, _3;
int ZEPHIR_LAST_CALL_STATUS;
zval *field = NULL;
zval *validation, *field_param = NULL, *value = NULL, *minimum = NULL, *maximum = NULL, *message = NULL, *label = NULL, *replacePairs = NULL, *_0 = NULL, *_1 = NULL, *_4$$4 = NULL, *_6$$4 = NULL, *_7$$4, *_5$$6;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &validation, &field_param);
if (unlikely(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 (likely(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_INIT_VAR(_0);
ZVAL_STRING(_0, "minimum", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&minimum, this_ptr, "getoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "maximum", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&maximum, this_ptr, "getoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "allowEmpty", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_1, this_ptr, "issetoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
_2 = zephir_is_true(_1);
if (_2) {
_2 = ZEPHIR_IS_EMPTY(value);
}
if (_2) {
RETURN_MM_BOOL(1);
}
_3 = ZEPHIR_LT(value, minimum);
if (!(_3)) {
_3 = ZEPHIR_GT(value, maximum);
}
if (_3) {
ZEPHIR_INIT_VAR(_4$$4);
ZVAL_STRING(_4$$4, "label", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&label, this_ptr, "getoption", NULL, 0, _4$$4);
zephir_check_temp_parameter(_4$$4);
zephir_check_call_status();
if (ZEPHIR_IS_EMPTY(label)) {
ZEPHIR_CALL_METHOD(&label, validation, "getlabel", NULL, 0, field);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_4$$4);
ZVAL_STRING(_4$$4, "message", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _4$$4);
zephir_check_temp_parameter(_4$$4);
zephir_check_call_status();
ZEPHIR_INIT_VAR(replacePairs);
zephir_create_array(replacePairs, 3, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&replacePairs, SL(":min"), &minimum, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&replacePairs, SL(":max"), &maximum, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_VAR(_5$$6);
ZVAL_STRING(_5$$6, "Between", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _5$$6);
zephir_check_temp_parameter(_5$$6);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_4$$4);
object_init_ex(_4$$4, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_6$$4, "strtr", NULL, 55, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_7$$4);
ZVAL_STRING(_7$$4, "Between", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _4$$4, "__construct", NULL, 434, _6$$4, field, _7$$4);
zephir_check_temp_parameter(_7$$4);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _4$$4);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
/**
* Sets a cookie to be sent at the end of the request
* This method overrides any cookie set before with the same name
*
* @param string name
* @param mixed value
* @param int expire
* @param string path
* @param boolean secure
* @param string domain
* @param boolean httpOnly
* @return Phalcon\Http\Response\Cookies
*/
PHP_METHOD(Phalcon_Http_Response_Cookies, set) {
int expire, ZEPHIR_LAST_CALL_STATUS;
zval *name_param = NULL, *value = NULL, *expire_param = NULL, *path_param = NULL, *secure = NULL, *domain_param = NULL, *httpOnly = NULL, *cookie = NULL, *encryption, *dependencyInjector, *response = NULL, *_0, *_1 = NULL, *_2;
zval *name = NULL, *path = NULL, *domain = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 6, &name_param, &value, &expire_param, &path_param, &secure, &domain_param, &httpOnly);
if (unlikely(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 (likely(Z_TYPE_P(name_param) == IS_STRING)) {
zephir_get_strval(name, name_param);
} else {
ZEPHIR_INIT_VAR(name);
ZVAL_EMPTY_STRING(name);
}
if (!value) {
value = ZEPHIR_GLOBAL(global_null);
}
if (!expire_param) {
expire = 0;
} else {
expire = zephir_get_intval(expire_param);
}
if (!path_param) {
ZEPHIR_INIT_VAR(path);
ZVAL_STRING(path, "/", 1);
} else {
zephir_get_strval(path, path_param);
}
if (!secure) {
secure = ZEPHIR_GLOBAL(global_null);
}
if (!domain_param) {
ZEPHIR_INIT_VAR(domain);
ZVAL_EMPTY_STRING(domain);
} else {
if (unlikely(Z_TYPE_P(domain_param) != IS_STRING && Z_TYPE_P(domain_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'domain' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(domain_param) == IS_STRING)) {
zephir_get_strval(domain, domain_param);
} else {
ZEPHIR_INIT_VAR(domain);
ZVAL_EMPTY_STRING(domain);
}
}
if (!httpOnly) {
httpOnly = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_OBS_VAR(encryption);
zephir_read_property_this(&encryption, this_ptr, SL("_useEncryption"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(cookie);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_cookies"), PH_NOISY_CC);
if (!(zephir_array_isset_fetch(&cookie, _0, name, 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(cookie);
object_init_ex(cookie, phalcon_http_cookie_ce);
ZEPHIR_INIT_VAR(_1);
ZVAL_LONG(_1, expire);
ZEPHIR_CALL_METHOD(NULL, cookie, "__construct", NULL, 213, name, value, _1, path, secure, domain, httpOnly);
zephir_check_call_status();
_2 = zephir_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, cookie, "setdi", NULL, 214, _2);
zephir_check_call_status();
if (zephir_is_true(encryption)) {
ZEPHIR_CALL_METHOD(NULL, cookie, "useencryption", NULL, 215, encryption);
zephir_check_call_status();
}
zephir_update_property_array(this_ptr, SL("_cookies"), name, cookie TSRMLS_CC);
} else {
ZEPHIR_CALL_METHOD(NULL, cookie, "setvalue", NULL, 216, value);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_1);
ZVAL_LONG(_1, expire);
ZEPHIR_CALL_METHOD(NULL, cookie, "setexpiration", NULL, 217, _1);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, cookie, "setpath", NULL, 218, path);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, cookie, "setsecure", NULL, 219, secure);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, cookie, "setdomain", NULL, 220, domain);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, cookie, "sethttponly", NULL, 221, httpOnly);
zephir_check_call_status();
}
_2 = zephir_fetch_nproperty_this(this_ptr, SL("_registered"), PH_NOISY_CC);
if (ZEPHIR_IS_FALSE_IDENTICAL(_2)) {
ZEPHIR_OBS_VAR(dependencyInjector);
zephir_read_property_this(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_http_cookie_exception_ce, "A dependency injection object is required to access the 'response' service", "phalcon/http/response/cookies.zep", 138);
return;
}
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "response", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&response, dependencyInjector, "getshared", NULL, 0, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, response, "setcookies", NULL, 0, this_ptr);
zephir_check_call_status();
}
RETURN_THIS();
}
/**
* Extracts parameters from a string
*/
PHP_METHOD(Phalcon_Mvc_Router_Route, extractNamedParams) {
long _0, _5$$11, _26$$19;
zend_bool notValid = 0, _6$$12, _7$$12, _8$$12, _9$$12, _10$$12, _11$$12, _12$$12, _13$$12, _14$$12, _15$$12, _16$$12, _17$$12, _25$$18;
int tmp = 0, cursor = 0, cursorVar = 0, marker = 0, bracketCount, parenthesesCount, foundPattern, intermediate, numberMatches;
char ch = 0;
zval *pattern_param = NULL, *matches = NULL, _1$$11 = zval_used_for_init, _2$$11 = zval_used_for_init, *_3$$11 = NULL, _18$$16 = zval_used_for_init, _19$$16 = zval_used_for_init, *_20$$16 = NULL, _22$$16 = zval_used_for_init, *_23$$16 = NULL, *_28$$19 = NULL, *_29$$28 = NULL;
zval *pattern = NULL, *route = NULL, *item = NULL, *variable = NULL, *regexp = NULL, *_4$$11 = NULL, *_21$$16 = NULL, *_24$$16 = NULL, *_27$$26 = NULL, *_30$$29 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &pattern_param);
if (unlikely(Z_TYPE_P(pattern_param) != IS_STRING && Z_TYPE_P(pattern_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'pattern' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(pattern_param) == IS_STRING)) {
zephir_get_strval(pattern, pattern_param);
} else {
ZEPHIR_INIT_VAR(pattern);
ZVAL_EMPTY_STRING(pattern);
}
bracketCount = 0;
parenthesesCount = 0;
foundPattern = 0;
intermediate = 0;
numberMatches = 0;
if (zephir_fast_strlen_ev(pattern) <= 0) {
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_VAR(matches);
array_init(matches);
ZEPHIR_INIT_VAR(route);
ZVAL_EMPTY_STRING(route);
for (_0 = 0; _0 < Z_STRLEN_P(pattern); _0++) {
cursor = _0;
ch = ZEPHIR_STRING_OFFSET(pattern, _0);
if (parenthesesCount == 0) {
if (ch == '{') {
if (bracketCount == 0) {
marker = (cursor + 1);
intermediate = 0;
notValid = 0;
}
bracketCount++;
} else {
if (ch == '}') {
bracketCount--;
if (intermediate > 0) {
if (bracketCount == 0) {
numberMatches++;
ZEPHIR_INIT_NVAR(variable);
ZVAL_EMPTY_STRING(variable);
ZEPHIR_INIT_NVAR(regexp);
ZVAL_EMPTY_STRING(regexp);
ZEPHIR_SINIT_NVAR(_1$$11);
ZVAL_LONG(&_1$$11, marker);
ZEPHIR_SINIT_NVAR(_2$$11);
ZVAL_LONG(&_2$$11, (cursor - marker));
ZEPHIR_INIT_NVAR(_3$$11);
zephir_substr(_3$$11, pattern, zephir_get_intval(&_1$$11), zephir_get_intval(&_2$$11), 0);
zephir_get_strval(_4$$11, _3$$11);
ZEPHIR_CPY_WRT(item, _4$$11);
for (_5$$11 = 0; _5$$11 < Z_STRLEN_P(item); _5$$11++) {
cursorVar = _5$$11;
ch = ZEPHIR_STRING_OFFSET(item, _5$$11);
if (ch == '\0') {
break;
}
_6$$12 = cursorVar == 0;
if (_6$$12) {
_7$$12 = ch >= 'a';
if (_7$$12) {
_7$$12 = ch <= 'z';
}
_8$$12 = _7$$12;
if (!(_8$$12)) {
_9$$12 = ch >= 'A';
if (_9$$12) {
_9$$12 = ch <= 'Z';
}
_8$$12 = _9$$12;
}
_6$$12 = !(_8$$12);
}
if (_6$$12) {
notValid = 1;
break;
}
_10$$12 = ch >= 'a';
if (_10$$12) {
_10$$12 = ch <= 'z';
}
_11$$12 = _10$$12;
if (!(_11$$12)) {
_12$$12 = ch >= 'A';
if (_12$$12) {
_12$$12 = ch <= 'Z';
}
_11$$12 = _12$$12;
}
_13$$12 = _11$$12;
if (!(_13$$12)) {
_14$$12 = ch >= '0';
if (_14$$12) {
_14$$12 = ch <= '9';
}
_13$$12 = _14$$12;
}
_15$$12 = _13$$12;
if (!(_15$$12)) {
_15$$12 = ch == '-';
}
_16$$12 = _15$$12;
if (!(_16$$12)) {
_16$$12 = ch == '_';
}
_17$$12 = _16$$12;
if (!(_17$$12)) {
_17$$12 = ch == ':';
}
if (_17$$12) {
if (ch == ':') {
ZEPHIR_SINIT_NVAR(_18$$16);
ZVAL_LONG(&_18$$16, 0);
ZEPHIR_SINIT_NVAR(_19$$16);
ZVAL_LONG(&_19$$16, cursorVar);
ZEPHIR_INIT_NVAR(_20$$16);
zephir_substr(_20$$16, item, 0 , zephir_get_intval(&_19$$16), 0);
zephir_get_strval(_21$$16, _20$$16);
ZEPHIR_CPY_WRT(variable, _21$$16);
ZEPHIR_SINIT_NVAR(_22$$16);
ZVAL_LONG(&_22$$16, (cursorVar + 1));
ZEPHIR_INIT_NVAR(_23$$16);
zephir_substr(_23$$16, item, zephir_get_intval(&_22$$16), 0, ZEPHIR_SUBSTR_NO_LENGTH);
zephir_get_strval(_24$$16, _23$$16);
ZEPHIR_CPY_WRT(regexp, _24$$16);
break;
}
} else {
notValid = 1;
break;
}
}
if (!(notValid)) {
tmp = numberMatches;
_25$$18 = zephir_is_true(variable);
if (_25$$18) {
_25$$18 = zephir_is_true(regexp);
}
if (_25$$18) {
foundPattern = 0;
for (_26$$19 = 0; _26$$19 < Z_STRLEN_P(regexp); _26$$19++) {
ch = ZEPHIR_STRING_OFFSET(regexp, _26$$19);
if (ch == '\0') {
break;
}
if (!(foundPattern)) {
if (ch == '(') {
foundPattern = 1;
}
} else {
if (ch == ')') {
foundPattern = 2;
break;
}
}
}
if (foundPattern != 2) {
ZEPHIR_INIT_LNVAR(_27$$26);
ZEPHIR_CONCAT_SVS(_27$$26, "(", regexp, ")");
zephir_concat_self(&route, _27$$26 TSRMLS_CC);
} else {
zephir_concat_self(&route, regexp TSRMLS_CC);
}
ZEPHIR_INIT_NVAR(_28$$19);
ZVAL_LONG(_28$$19, tmp);
zephir_array_update_zval(&matches, variable, &_28$$19, PH_COPY | PH_SEPARATE);
} else {
zephir_concat_self_str(&route, "([^/]*)", sizeof("([^/]*)")-1 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_29$$28);
ZVAL_LONG(_29$$28, tmp);
zephir_array_update_zval(&matches, item, &_29$$28, PH_COPY | PH_SEPARATE);
}
} else {
ZEPHIR_INIT_LNVAR(_30$$29);
ZEPHIR_CONCAT_SVS(_30$$29, "{", item, "}");
zephir_concat_self(&route, _30$$29 TSRMLS_CC);
}
continue;
}
}
}
}
}
if (bracketCount == 0) {
if (ch == '(') {
parenthesesCount++;
} else {
if (ch == ')') {
parenthesesCount--;
if (parenthesesCount == 0) {
numberMatches++;
}
}
}
}
if (bracketCount > 0) {
intermediate++;
} else {
zephir_concat_self_char(&route, ch TSRMLS_CC);
}
}
zephir_create_array(return_value, 2, 0 TSRMLS_CC);
zephir_array_fast_append(return_value, route);
zephir_array_fast_append(return_value, matches);
RETURN_MM();
}
/**
* Phalcon\Config\Adapter\Ini constructor
*/
PHP_METHOD(Phalcon_Config_Adapter_Ini, __construct) {
zephir_fcall_cache_entry *_10 = NULL, *_12 = NULL;
HashTable *_4, *_7;
HashPosition _3, _6;
int ZEPHIR_LAST_CALL_STATUS;
zval *filePath_param = NULL, *iniConfig = NULL, *_0 = NULL, *_1, *_2, *config, *section = NULL, *sections = NULL, *directives = NULL, *path = NULL, *lastValue = NULL, **_5, **_8, *_9 = NULL, _11 = zval_used_for_init;
zval *filePath = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &filePath_param);
if (unlikely(Z_TYPE_P(filePath_param) != IS_STRING && Z_TYPE_P(filePath_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'filePath' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(filePath_param) == IS_STRING)) {
zephir_get_strval(filePath, filePath_param);
} else {
ZEPHIR_INIT_VAR(filePath);
ZVAL_EMPTY_STRING(filePath);
}
ZEPHIR_CALL_FUNCTION(&iniConfig, "parse_ini_file", NULL, 61, filePath, ZEPHIR_GLOBAL(global_true));
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(iniConfig)) {
ZEPHIR_INIT_VAR(_0);
object_init_ex(_0, phalcon_config_exception_ce);
ZEPHIR_INIT_VAR(_1);
zephir_basename(_1, filePath TSRMLS_CC);
ZEPHIR_INIT_VAR(_2);
ZEPHIR_CONCAT_SVS(_2, "Configuration file ", _1, " can't be loaded");
ZEPHIR_CALL_METHOD(NULL, _0, "__construct", NULL, 2, _2);
zephir_check_call_status();
zephir_throw_exception_debug(_0, "phalcon/config/adapter/ini.zep", 67 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_INIT_VAR(config);
array_init(config);
zephir_is_iterable(iniConfig, &_4, &_3, 0, 0, "phalcon/config/adapter/ini.zep", 82);
for (
; zephir_hash_get_current_data_ex(_4, (void**) &_5, &_3) == SUCCESS
; zephir_hash_move_forward_ex(_4, &_3)
) {
ZEPHIR_GET_HMKEY(section, _4, _3);
ZEPHIR_GET_HVALUE(directives, _5);
ZEPHIR_INIT_NVAR(sections);
array_init(sections);
zephir_is_iterable(directives, &_7, &_6, 0, 0, "phalcon/config/adapter/ini.zep", 79);
for (
; zephir_hash_get_current_data_ex(_7, (void**) &_8, &_6) == SUCCESS
; zephir_hash_move_forward_ex(_7, &_6)
) {
ZEPHIR_GET_HMKEY(path, _7, _6);
ZEPHIR_GET_HVALUE(lastValue, _8);
ZEPHIR_CALL_METHOD(&_9, this_ptr, "_parseinistring", &_10, 0, path, lastValue);
zephir_check_call_status();
zephir_array_append(§ions, _9, PH_SEPARATE, "phalcon/config/adapter/ini.zep", 77);
}
ZEPHIR_INIT_NVAR(_0);
ZEPHIR_SINIT_NVAR(_11);
ZVAL_STRING(&_11, "array_merge_recursive", 0);
ZEPHIR_CALL_USER_FUNC_ARRAY(_0, &_11, sections);
zephir_check_call_status();
zephir_array_update_zval(&config, section, &_0, PH_COPY | PH_SEPARATE);
}
ZEPHIR_CALL_PARENT(NULL, phalcon_config_adapter_ini_ce, this_ptr, "__construct", &_12, 58, config);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Set an specific argument
*/
PHP_METHOD(Phalcon_Cli_Console, setArgument) {
zephir_fcall_cache_entry *_5 = NULL, *_24 = NULL;
zend_long ZEPHIR_LAST_CALL_STATUS;
zend_bool str, shift, _0;
zval *arguments_param = NULL, *str_param = NULL, *shift_param = NULL, __$true, arg, pos, args, opts, handleArgs, *_1, _2$$5, _3$$5, _4$$5, _6$$6, _7$$7, _8$$7, _9$$7, _10$$7, _11$$7, _12$$7, _13$$7, _14$$8, _15$$8, _16$$8, _17$$9, _18$$9, _19$$9, _20$$10, _21$$10, _22$$13, _23$$13, _25$$15, _26$$16, _27$$17;
zval arguments;
zval *this_ptr = getThis();
ZVAL_UNDEF(&arguments);
ZVAL_BOOL(&__$true, 1);
ZVAL_UNDEF(&arg);
ZVAL_UNDEF(&pos);
ZVAL_UNDEF(&args);
ZVAL_UNDEF(&opts);
ZVAL_UNDEF(&handleArgs);
ZVAL_UNDEF(&_2$$5);
ZVAL_UNDEF(&_3$$5);
ZVAL_UNDEF(&_4$$5);
ZVAL_UNDEF(&_6$$6);
ZVAL_UNDEF(&_7$$7);
ZVAL_UNDEF(&_8$$7);
ZVAL_UNDEF(&_9$$7);
ZVAL_UNDEF(&_10$$7);
ZVAL_UNDEF(&_11$$7);
ZVAL_UNDEF(&_12$$7);
ZVAL_UNDEF(&_13$$7);
ZVAL_UNDEF(&_14$$8);
ZVAL_UNDEF(&_15$$8);
ZVAL_UNDEF(&_16$$8);
ZVAL_UNDEF(&_17$$9);
ZVAL_UNDEF(&_18$$9);
ZVAL_UNDEF(&_19$$9);
ZVAL_UNDEF(&_20$$10);
ZVAL_UNDEF(&_21$$10);
ZVAL_UNDEF(&_22$$13);
ZVAL_UNDEF(&_23$$13);
ZVAL_UNDEF(&_25$$15);
ZVAL_UNDEF(&_26$$16);
ZVAL_UNDEF(&_27$$17);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 3, &arguments_param, &str_param, &shift_param);
if (!arguments_param) {
ZEPHIR_INIT_VAR(&arguments);
array_init(&arguments);
} else {
ZEPHIR_OBS_COPY_OR_DUP(&arguments, arguments_param);
}
if (!str_param) {
str = 1;
} else {
if (UNEXPECTED(Z_TYPE_P(str_param) != IS_TRUE && Z_TYPE_P(str_param) != IS_FALSE)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'str' must be of the type bool") TSRMLS_CC);
RETURN_MM_NULL();
}
str = (Z_TYPE_P(str_param) == IS_TRUE);
}
if (!shift_param) {
shift = 1;
} else {
if (UNEXPECTED(Z_TYPE_P(shift_param) != IS_TRUE && Z_TYPE_P(shift_param) != IS_FALSE)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'shift' must be of the type bool") TSRMLS_CC);
RETURN_MM_NULL();
}
shift = (Z_TYPE_P(shift_param) == IS_TRUE);
}
ZEPHIR_INIT_VAR(&args);
array_init(&args);
ZEPHIR_INIT_VAR(&opts);
array_init(&opts);
ZEPHIR_INIT_VAR(&handleArgs);
array_init(&handleArgs);
_0 = shift;
if (_0) {
_0 = ((zephir_fast_count_int(&arguments TSRMLS_CC)) ? 1 : 0);
}
if (_0) {
ZEPHIR_MAKE_REF(&arguments);
ZEPHIR_CALL_FUNCTION(NULL, "array_shift", NULL, 11, &arguments);
ZEPHIR_UNREF(&arguments);
zephir_check_call_status();
}
zephir_is_iterable(&arguments, 0, "phalcon/cli/console.zep", 176);
ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&arguments), _1)
{
ZEPHIR_INIT_NVAR(&arg);
ZVAL_COPY(&arg, _1);
if (Z_TYPE_P(&arg) == IS_STRING) {
ZEPHIR_INIT_NVAR(&_2$$5);
ZVAL_STRING(&_2$$5, "--");
ZVAL_LONG(&_3$$5, 2);
ZEPHIR_CALL_FUNCTION(&_4$$5, "strncmp", &_5, 117, &arg, &_2$$5, &_3$$5);
zephir_check_call_status();
if (ZEPHIR_IS_LONG(&_4$$5, 0)) {
ZEPHIR_INIT_NVAR(&_6$$6);
ZVAL_STRING(&_6$$6, "=");
ZEPHIR_INIT_NVAR(&pos);
zephir_fast_strpos(&pos, &arg, &_6$$6, 0 );
if (zephir_is_true(&pos)) {
ZEPHIR_INIT_NVAR(&_7$$7);
ZVAL_LONG(&_8$$7, (zephir_get_numberval(&pos) + 1));
ZEPHIR_INIT_NVAR(&_9$$7);
zephir_substr(&_9$$7, &arg, zephir_get_intval(&_8$$7), 0, ZEPHIR_SUBSTR_NO_LENGTH);
zephir_fast_trim(&_7$$7, &_9$$7, NULL , ZEPHIR_TRIM_BOTH TSRMLS_CC);
ZEPHIR_INIT_NVAR(&_10$$7);
ZVAL_LONG(&_11$$7, 2);
ZVAL_LONG(&_12$$7, (zephir_get_numberval(&pos) - 2));
ZEPHIR_INIT_NVAR(&_13$$7);
zephir_substr(&_13$$7, &arg, 2 , zephir_get_intval(&_12$$7), 0);
zephir_fast_trim(&_10$$7, &_13$$7, NULL , ZEPHIR_TRIM_BOTH TSRMLS_CC);
zephir_array_update_zval(&opts, &_10$$7, &_7$$7, PH_COPY | PH_SEPARATE);
} else {
ZEPHIR_INIT_NVAR(&_14$$8);
ZVAL_LONG(&_15$$8, 2);
ZEPHIR_INIT_NVAR(&_16$$8);
zephir_substr(&_16$$8, &arg, 2 , 0, ZEPHIR_SUBSTR_NO_LENGTH);
zephir_fast_trim(&_14$$8, &_16$$8, NULL , ZEPHIR_TRIM_BOTH TSRMLS_CC);
zephir_array_update_zval(&opts, &_14$$8, &__$true, PH_COPY | PH_SEPARATE);
}
} else {
ZEPHIR_INIT_NVAR(&_17$$9);
ZVAL_STRING(&_17$$9, "-");
ZVAL_LONG(&_18$$9, 1);
ZEPHIR_CALL_FUNCTION(&_19$$9, "strncmp", &_5, 117, &arg, &_17$$9, &_18$$9);
zephir_check_call_status();
if (ZEPHIR_IS_LONG(&_19$$9, 0)) {
ZVAL_LONG(&_20$$10, 1);
ZEPHIR_INIT_NVAR(&_21$$10);
zephir_substr(&_21$$10, &arg, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH);
zephir_array_update_zval(&opts, &_21$$10, &__$true, PH_COPY | PH_SEPARATE);
} else {
zephir_array_append(&args, &arg, PH_SEPARATE, "phalcon/cli/console.zep", 168);
}
}
} else {
zephir_array_append(&args, &arg, PH_SEPARATE, "phalcon/cli/console.zep", 172);
}
} ZEND_HASH_FOREACH_END();
/**
* Gets a value from the internal related entity or from the default value
*/
PHP_METHOD(Phalcon_Forms_Form, getValue) {
int ZEPHIR_LAST_CALL_STATUS;
zval *name_param = NULL, *entity = NULL, *method = NULL, *value = NULL, *data = NULL, *internal = NULL, *forbidden = NULL, *_1, *_0$$4;
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_OBS_VAR(entity);
zephir_read_property_this(&entity, this_ptr, SL("_entity"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(data);
zephir_read_property_this(&data, this_ptr, SL("_data"), PH_NOISY_CC);
if ((zephir_method_exists_ex(this_ptr, SS("getcustomvalue") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getcustomvalue", NULL, 0, name, entity, data);
zephir_check_call_status();
RETURN_MM();
}
if (Z_TYPE_P(entity) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_0$$4);
zephir_camelize(_0$$4, name, NULL );
ZEPHIR_INIT_VAR(method);
ZEPHIR_CONCAT_SV(method, "get", _0$$4);
if ((zephir_method_exists(entity, method TSRMLS_CC) == SUCCESS)) {
ZEPHIR_RETURN_CALL_METHOD_ZVAL(entity, method, NULL, 0);
zephir_check_call_status();
RETURN_MM();
}
ZEPHIR_OBS_VAR(value);
if (zephir_fetch_property_zval(&value, entity, name, PH_SILENT_CC)) {
RETURN_CCTOR(value);
}
}
if (Z_TYPE_P(data) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(value);
if (zephir_array_isset_fetch(&value, data, name, 0 TSRMLS_CC)) {
RETURN_CCTOR(value);
}
}
ZEPHIR_INIT_VAR(forbidden);
zephir_create_array(forbidden, 12, 0 TSRMLS_CC);
zephir_array_update_string(&forbidden, SL("validation"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("action"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("useroption"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("useroptions"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("entity"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("elements"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("messages"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("messagesfor"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("label"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("value"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("di"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&forbidden, SL("eventsmanager"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_VAR(internal);
zephir_fast_strtolower(internal, name);
if (zephir_array_isset(forbidden, internal)) {
RETURN_MM_NULL();
}
ZEPHIR_INIT_VAR(_1);
zephir_camelize(_1, name, NULL );
ZEPHIR_INIT_NVAR(method);
ZEPHIR_CONCAT_SV(method, "get", _1);
if ((zephir_method_exists(this_ptr, method TSRMLS_CC) == SUCCESS)) {
ZEPHIR_RETURN_CALL_METHOD_ZVAL(this_ptr, method, NULL, 0);
zephir_check_call_status();
RETURN_MM();
}
RETURN_MM_NULL();
}
/**
* Returns an array of Phalcon\Db\Column objects describing a table
*
* <code>print_r($connection->describeColumns("posts")); ?></code>
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Oracle, describeColumns) {
zephir_fcall_cache_entry *_11 = NULL;
HashTable *_5;
HashPosition _4;
int ZEPHIR_LAST_CALL_STATUS;
zval *table_param = NULL, *schema_param = NULL, *columns, *oldColumn = NULL, *field = NULL, *definition = NULL, *columnSize = NULL, *columnPrecision = NULL, *columnScale = NULL, *columnType = NULL, *columnName, *_0 = NULL, *_1, *_2 = NULL, *_3 = NULL, **_6, *_7 = NULL, *_8 = NULL, *_9, *_10;
zval *table = NULL, *schema = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &table_param, &schema_param);
if (unlikely(Z_TYPE_P(table_param) != IS_STRING && Z_TYPE_P(table_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'table' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(table_param) == IS_STRING)) {
zephir_get_strval(table, table_param);
} else {
ZEPHIR_INIT_VAR(table);
ZVAL_EMPTY_STRING(table);
}
if (!schema_param) {
ZEPHIR_INIT_VAR(schema);
ZVAL_EMPTY_STRING(schema);
} else {
zephir_get_strval(schema, schema_param);
}
ZEPHIR_INIT_VAR(columns);
array_init(columns);
ZEPHIR_INIT_VAR(oldColumn);
ZVAL_NULL(oldColumn);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_dialect"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&_2, _1, "describecolumns", NULL, 0, table, schema);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_3);
ZVAL_LONG(_3, 3);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "fetchall", NULL, 0, _2, _3);
zephir_check_call_status();
zephir_is_iterable(_0, &_5, &_4, 0, 0, "phalcon/db/adapter/pdo/oracle.zep", 203);
for (
; zephir_hash_get_current_data_ex(_5, (void**) &_6, &_4) == SUCCESS
; zephir_hash_move_forward_ex(_5, &_4)
) {
ZEPHIR_GET_HVALUE(field, _6);
ZEPHIR_INIT_NVAR(definition);
zephir_create_array(definition, 1, 0 TSRMLS_CC);
add_assoc_long_ex(definition, SS("bindType"), 2);
ZEPHIR_OBS_NVAR(columnSize);
zephir_array_fetch_long(&columnSize, field, 2, PH_NOISY, "phalcon/db/adapter/pdo/oracle.zep", 102 TSRMLS_CC);
ZEPHIR_OBS_NVAR(columnPrecision);
zephir_array_fetch_long(&columnPrecision, field, 3, PH_NOISY, "phalcon/db/adapter/pdo/oracle.zep", 103 TSRMLS_CC);
ZEPHIR_OBS_NVAR(columnScale);
zephir_array_fetch_long(&columnScale, field, 4, PH_NOISY, "phalcon/db/adapter/pdo/oracle.zep", 104 TSRMLS_CC);
ZEPHIR_OBS_NVAR(columnType);
zephir_array_fetch_long(&columnType, field, 1, PH_NOISY, "phalcon/db/adapter/pdo/oracle.zep", 105 TSRMLS_CC);
while (1) {
if (zephir_memnstr_str(columnType, SL("NUMBER"), "phalcon/db/adapter/pdo/oracle.zep", 112)) {
ZEPHIR_INIT_NVAR(_3);
ZVAL_LONG(_3, 3);
zephir_array_update_string(&definition, SL("type"), &_3, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&definition, SL("isNumeric"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&definition, SL("size"), &columnPrecision, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&definition, SL("scale"), &columnScale, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 32);
zephir_array_update_string(&definition, SL("bindType"), &_7, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("INTEGER"), "phalcon/db/adapter/pdo/oracle.zep", 121)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 0);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&definition, SL("isNumeric"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&definition, SL("size"), &columnPrecision, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_8);
ZVAL_LONG(_8, 1);
zephir_array_update_string(&definition, SL("bindType"), &_8, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("VARCHAR2"), "phalcon/db/adapter/pdo/oracle.zep", 129)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 2);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&definition, SL("size"), &columnSize, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("FLOAT"), "phalcon/db/adapter/pdo/oracle.zep", 135)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 7);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&definition, SL("isNumeric"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&definition, SL("size"), &columnSize, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&definition, SL("scale"), &columnScale, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_8);
ZVAL_LONG(_8, 32);
zephir_array_update_string(&definition, SL("bindType"), &_8, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("TIMESTAMP"), "phalcon/db/adapter/pdo/oracle.zep", 144)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 0);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("RAW"), "phalcon/db/adapter/pdo/oracle.zep", 149)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 6);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("BLOB"), "phalcon/db/adapter/pdo/oracle.zep", 154)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 6);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("CLOB"), "phalcon/db/adapter/pdo/oracle.zep", 159)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 6);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
break;
}
if (zephir_memnstr_str(columnType, SL("CHAR"), "phalcon/db/adapter/pdo/oracle.zep", 164)) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 5);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
zephir_array_update_string(&definition, SL("size"), &columnSize, PH_COPY | PH_SEPARATE);
break;
}
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, 6);
zephir_array_update_string(&definition, SL("type"), &_7, PH_COPY | PH_SEPARATE);
break;
}
if (Z_TYPE_P(oldColumn) == IS_NULL) {
zephir_array_update_string(&definition, SL("first"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
} else {
zephir_array_update_string(&definition, SL("after"), &oldColumn, PH_COPY | PH_SEPARATE);
}
zephir_array_fetch_long(&_9, field, 6, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/oracle.zep", 183 TSRMLS_CC);
if (ZEPHIR_IS_STRING(_9, "P")) {
zephir_array_update_string(&definition, SL("primary"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
}
zephir_array_fetch_long(&_10, field, 5, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/oracle.zep", 190 TSRMLS_CC);
if (ZEPHIR_IS_STRING(_10, "N")) {
zephir_array_update_string(&definition, SL("notNull"), &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
}
zephir_array_fetch_long(&columnName, field, 0, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/oracle.zep", 194 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_8);
object_init_ex(_8, phalcon_db_column_ce);
ZEPHIR_CALL_METHOD(NULL, _8, "__construct", &_11, 138, columnName, definition);
zephir_check_call_status();
zephir_array_append(&columns, _8, PH_SEPARATE, "phalcon/db/adapter/pdo/oracle.zep", 199);
ZEPHIR_CPY_WRT(oldColumn, columnName);
}
RETURN_CCTOR(columns);
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_Regex, validate) {
zend_bool failed = 0;
int ZEPHIR_LAST_CALL_STATUS;
zval *field = NULL;
zval *validation, *field_param = NULL, *matches = NULL, *message = NULL, *value = NULL, *label = NULL, *replacePairs = NULL, *code = NULL, *pattern = NULL, *_0 = NULL, *_1$$3, *_2$$4, *_3$$6 = NULL, *_8$$6 = NULL, *_9$$6, *_4$$7, *_5$$9, *_6$$10, *_7$$11;
ZEPHIR_MM_GROW();
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_INIT_VAR(matches);
ZVAL_NULL(matches);
ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "pattern", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&pattern, this_ptr, "getoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (Z_TYPE_P(pattern) == IS_ARRAY) {
zephir_array_fetch(&_1$$3, pattern, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/regex.zep", 81 TSRMLS_CC);
ZEPHIR_CPY_WRT(pattern, _1$$3);
}
ZEPHIR_INIT_NVAR(_0);
zephir_preg_match(_0, pattern, value, matches, 0, 0 , 0 TSRMLS_CC);
if (zephir_is_true(_0)) {
zephir_array_fetch_long(&_2$$4, matches, 0, PH_NOISY | PH_READONLY, "phalcon/validation/validator/regex.zep", 85 TSRMLS_CC);
failed = !ZEPHIR_IS_EQUAL(_2$$4, value);
} else {
failed = 1;
}
if (failed == 1) {
ZEPHIR_INIT_VAR(_3$$6);
ZVAL_STRING(_3$$6, "label", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&label, this_ptr, "getoption", NULL, 0, _3$$6);
zephir_check_temp_parameter(_3$$6);
zephir_check_call_status();
if (Z_TYPE_P(label) == IS_ARRAY) {
zephir_array_fetch(&_4$$7, label, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/regex.zep", 94 TSRMLS_CC);
ZEPHIR_CPY_WRT(label, _4$$7);
}
if (ZEPHIR_IS_EMPTY(label)) {
ZEPHIR_CALL_METHOD(&label, validation, "getlabel", NULL, 0, field);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_3$$6);
ZVAL_STRING(_3$$6, "message", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _3$$6);
zephir_check_temp_parameter(_3$$6);
zephir_check_call_status();
if (Z_TYPE_P(message) == IS_ARRAY) {
zephir_array_fetch(&_5$$9, message, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/regex.zep", 102 TSRMLS_CC);
ZEPHIR_CPY_WRT(message, _5$$9);
}
ZEPHIR_INIT_VAR(replacePairs);
zephir_create_array(replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_VAR(_6$$10);
ZVAL_STRING(_6$$10, "Regex", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _6$$10);
zephir_check_temp_parameter(_6$$10);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_3$$6);
ZVAL_STRING(_3$$6, "code", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&code, this_ptr, "getoption", NULL, 0, _3$$6);
zephir_check_temp_parameter(_3$$6);
zephir_check_call_status();
if (Z_TYPE_P(code) == IS_ARRAY) {
zephir_array_fetch(&_7$$11, code, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/regex.zep", 111 TSRMLS_CC);
ZEPHIR_CPY_WRT(code, _7$$11);
}
ZEPHIR_INIT_NVAR(_3$$6);
object_init_ex(_3$$6, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_8$$6, "strtr", NULL, 26, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_9$$6);
ZVAL_STRING(_9$$6, "Regex", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _3$$6, "__construct", NULL, 464, _8$$6, field, _9$$6, code);
zephir_check_temp_parameter(_9$$6);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _3$$6);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_Date, validate) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *field = NULL;
zval *validation, *field_param = NULL, *value = NULL, *format = NULL, *label = NULL, *message = NULL, *replacePairs = NULL, *code = NULL, *_0, *_2 = NULL, *_1$$3, *_3$$5 = NULL, *_4$$5 = NULL, *_5$$5;
ZEPHIR_MM_GROW();
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_INIT_VAR(_0);
ZVAL_STRING(_0, "format", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&format, this_ptr, "getoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (Z_TYPE_P(format) == IS_ARRAY) {
zephir_array_fetch(&_1$$3, format, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/date.zep", 80 TSRMLS_CC);
ZEPHIR_CPY_WRT(format, _1$$3);
}
if (ZEPHIR_IS_EMPTY(format)) {
ZEPHIR_INIT_NVAR(format);
ZVAL_STRING(format, "Y-m-d", 1);
}
ZEPHIR_CALL_METHOD(&_2, this_ptr, "checkdate", NULL, 476, value, format);
zephir_check_call_status();
if (!(zephir_is_true(_2))) {
ZEPHIR_CALL_METHOD(&label, this_ptr, "preparelabel", NULL, 0, validation, field);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_3$$5);
ZVAL_STRING(_3$$5, "Date", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, _3$$5);
zephir_check_temp_parameter(_3$$5);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&code, this_ptr, "preparecode", NULL, 0, field);
zephir_check_call_status();
ZEPHIR_INIT_VAR(replacePairs);
zephir_create_array(replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_3$$5);
object_init_ex(_3$$5, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_4$$5, "strtr", NULL, 27, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_5$$5);
ZVAL_STRING(_5$$5, "Date", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _3$$5, "__construct", NULL, 470, _4$$5, field, _5$$5, code);
zephir_check_temp_parameter(_5$$5);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _3$$5);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
/**
* Performs a string conversion
*/
PHP_METHOD(Phalcon_Mvc_View_Engine_Volt, convertEncoding) {
zend_bool _0, _1;
int ZEPHIR_LAST_CALL_STATUS;
zval *text_param = NULL, *from_param = NULL, *to_param = NULL;
zval *text = NULL, *from = NULL, *to = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 0, &text_param, &from_param, &to_param);
zephir_get_strval(text, text_param);
if (unlikely(Z_TYPE_P(from_param) != IS_STRING && Z_TYPE_P(from_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'from' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(from_param) == IS_STRING)) {
zephir_get_strval(from, from_param);
} else {
ZEPHIR_INIT_VAR(from);
ZVAL_EMPTY_STRING(from);
}
if (unlikely(Z_TYPE_P(to_param) != IS_STRING && Z_TYPE_P(to_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'to' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(to_param) == IS_STRING)) {
zephir_get_strval(to, to_param);
} else {
ZEPHIR_INIT_VAR(to);
ZVAL_EMPTY_STRING(to);
}
_0 = ZEPHIR_IS_STRING(from, "latin1");
if (!(_0)) {
_0 = ZEPHIR_IS_STRING(to, "utf8");
}
if (_0) {
ZEPHIR_RETURN_CALL_FUNCTION("utf8_encode", NULL, 371, text);
zephir_check_call_status();
RETURN_MM();
}
_1 = ZEPHIR_IS_STRING(to, "latin1");
if (!(_1)) {
_1 = ZEPHIR_IS_STRING(from, "utf8");
}
if (_1) {
ZEPHIR_RETURN_CALL_FUNCTION("utf8_decode", NULL, 372, text);
zephir_check_call_status();
RETURN_MM();
}
if ((zephir_function_exists_ex(SS("mb_convert_encoding") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_RETURN_CALL_FUNCTION("mb_convert_encoding", NULL, 179, text, from, to);
zephir_check_call_status();
RETURN_MM();
}
if ((zephir_function_exists_ex(SS("iconv") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_RETURN_CALL_FUNCTION("iconv", NULL, 373, from, to, text);
zephir_check_call_status();
RETURN_MM();
}
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_view_exception_ce, "Any of 'mbstring' or 'iconv' is required to perform the charset conversion", "phalcon/mvc/view/engine/volt.zep", 205);
return;
}
/**
* Renders a view
*
* @param string path
* @param array params
* @return string
*/
PHP_METHOD(Phalcon_Mvc_View_Simple, render) {
int ZEPHIR_LAST_CALL_STATUS;
zval *path_param = NULL, *params = NULL, *cache = NULL, *key = NULL, *lifetime = NULL, *cacheOptions, *content = NULL, *viewParams, *mergedParams = NULL, *_0 = NULL, *_1, *_2 = NULL;
zval *path = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &path_param, ¶ms);
if (unlikely(Z_TYPE_P(path_param) != IS_STRING && Z_TYPE_P(path_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'path' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(path_param) == IS_STRING)) {
zephir_get_strval(path, path_param);
} else {
ZEPHIR_INIT_VAR(path);
ZVAL_EMPTY_STRING(path);
}
if (!params) {
params = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_CALL_METHOD(&cache, this_ptr, "getcache", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(cache) == IS_OBJECT) {
ZEPHIR_CALL_METHOD(&_0, cache, "isstarted", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_0)) {
ZEPHIR_INIT_VAR(key);
ZVAL_NULL(key);
ZEPHIR_INIT_VAR(lifetime);
ZVAL_NULL(lifetime);
ZEPHIR_OBS_VAR(cacheOptions);
zephir_read_property_this(&cacheOptions, this_ptr, SL("_cacheOptions"), PH_NOISY_CC);
if (Z_TYPE_P(cacheOptions) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(key);
zephir_array_isset_string_fetch(&key, cacheOptions, SS("key"), 0 TSRMLS_CC);
ZEPHIR_OBS_NVAR(lifetime);
zephir_array_isset_string_fetch(&lifetime, cacheOptions, SS("lifetime"), 0 TSRMLS_CC);
}
if (Z_TYPE_P(key) == IS_NULL) {
ZEPHIR_INIT_NVAR(key);
zephir_md5(key, path);
}
ZEPHIR_CALL_METHOD(&content, cache, "start", NULL, 0, key, lifetime);
zephir_check_call_status();
if (Z_TYPE_P(content) != IS_NULL) {
zephir_update_property_this(this_ptr, SL("_content"), content TSRMLS_CC);
RETURN_CCTOR(content);
}
}
}
ZEPHIR_INIT_VAR(_1);
zephir_create_symbol_table(TSRMLS_C);
ZEPHIR_CALL_FUNCTION(NULL, "ob_start", NULL, 119);
zephir_check_call_status();
ZEPHIR_OBS_VAR(viewParams);
zephir_read_property_this(&viewParams, this_ptr, SL("_viewParams"), PH_NOISY_CC);
if (Z_TYPE_P(params) == IS_ARRAY) {
if (Z_TYPE_P(viewParams) == IS_ARRAY) {
ZEPHIR_INIT_VAR(mergedParams);
zephir_fast_array_merge(mergedParams, &(viewParams), &(params) TSRMLS_CC);
} else {
ZEPHIR_CPY_WRT(mergedParams, params);
}
} else {
ZEPHIR_CPY_WRT(mergedParams, viewParams);
}
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_internalrender", NULL, 383, path, mergedParams);
zephir_check_call_status();
if (Z_TYPE_P(cache) == IS_OBJECT) {
ZEPHIR_CALL_METHOD(&_0, cache, "isstarted", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_TRUE_IDENTICAL(_0)) {
ZEPHIR_CALL_METHOD(&_2, cache, "isfresh", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_TRUE_IDENTICAL(_2)) {
ZEPHIR_CALL_METHOD(NULL, cache, "save", NULL, 0);
zephir_check_call_status();
} else {
ZEPHIR_CALL_METHOD(NULL, cache, "stop", NULL, 0);
zephir_check_call_status();
}
} else {
ZEPHIR_CALL_METHOD(NULL, cache, "stop", NULL, 0);
zephir_check_call_status();
}
}
ZEPHIR_CALL_FUNCTION(NULL, "ob_end_clean", NULL, 121);
zephir_check_call_status();
RETURN_MM_MEMBER(this_ptr, "_content");
}
/**
* Generates random text in accordance with the template
*
* <code>
* echo Phalcon\Text::dynamic("{Hi|Hello}, my name is a {Bob|Mark|Jon}!"); // Hi my name is a Bob
* echo Phalcon\Text::dynamic("{Hi|Hello}, my name is a {Bob|Mark|Jon}!"); // Hi my name is a Jon
* echo Phalcon\Text::dynamic("{Hi|Hello}, my name is a {Bob|Mark|Jon}!"); // Hello my name is a Bob
* </code>
*/
PHP_METHOD(Phalcon_Text, dynamic) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_1 = NULL, *_5 = NULL, *_7 = NULL;
zval *text_param = NULL, *leftDelimiter_param = NULL, *rightDelimiter_param = NULL, *separator_param = NULL, *ld_s = NULL, *rd_s = NULL, *result = NULL, *pattern, *_0 = NULL, *_2 = NULL, *_3 = NULL, *_6 = NULL;
zval *text = NULL, *leftDelimiter = NULL, *rightDelimiter = NULL, *separator = NULL, *_4;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 3, &text_param, &leftDelimiter_param, &rightDelimiter_param, &separator_param);
if (unlikely(Z_TYPE_P(text_param) != IS_STRING && Z_TYPE_P(text_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'text' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(text_param) == IS_STRING)) {
zephir_get_strval(text, text_param);
} else {
ZEPHIR_INIT_VAR(text);
ZVAL_EMPTY_STRING(text);
}
if (!leftDelimiter_param) {
ZEPHIR_INIT_VAR(leftDelimiter);
ZVAL_STRING(leftDelimiter, "{", 1);
} else {
if (unlikely(Z_TYPE_P(leftDelimiter_param) != IS_STRING && Z_TYPE_P(leftDelimiter_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'leftDelimiter' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(leftDelimiter_param) == IS_STRING)) {
zephir_get_strval(leftDelimiter, leftDelimiter_param);
} else {
ZEPHIR_INIT_VAR(leftDelimiter);
ZVAL_EMPTY_STRING(leftDelimiter);
}
}
if (!rightDelimiter_param) {
ZEPHIR_INIT_VAR(rightDelimiter);
ZVAL_STRING(rightDelimiter, "}", 1);
} else {
if (unlikely(Z_TYPE_P(rightDelimiter_param) != IS_STRING && Z_TYPE_P(rightDelimiter_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'rightDelimiter' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(rightDelimiter_param) == IS_STRING)) {
zephir_get_strval(rightDelimiter, rightDelimiter_param);
} else {
ZEPHIR_INIT_VAR(rightDelimiter);
ZVAL_EMPTY_STRING(rightDelimiter);
}
}
if (!separator_param) {
ZEPHIR_INIT_VAR(separator);
ZVAL_STRING(separator, "|", 1);
} else {
if (unlikely(Z_TYPE_P(separator_param) != IS_STRING && Z_TYPE_P(separator_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'separator' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(separator_param) == IS_STRING)) {
zephir_get_strval(separator, separator_param);
} else {
ZEPHIR_INIT_VAR(separator);
ZVAL_EMPTY_STRING(separator);
}
}
ZEPHIR_CALL_FUNCTION(&_0, "substr_count", &_1, 420, text, leftDelimiter);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&_2, "substr_count", &_1, 420, text, rightDelimiter);
zephir_check_call_status();
if (!ZEPHIR_IS_IDENTICAL(_0, _2)) {
ZEPHIR_INIT_VAR(_3);
object_init_ex(_3, spl_ce_RuntimeException);
ZEPHIR_INIT_VAR(_4);
ZEPHIR_CONCAT_SVS(_4, "Syntax error in string \"", text, "\"");
ZEPHIR_CALL_METHOD(NULL, _3, "__construct", NULL, 421, _4);
zephir_check_call_status();
zephir_throw_exception_debug(_3, "phalcon/text.zep", 265 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_CALL_FUNCTION(&ld_s, "preg_quote", &_5, 422, leftDelimiter);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&rd_s, "preg_quote", &_5, 422, rightDelimiter);
zephir_check_call_status();
ZEPHIR_INIT_VAR(pattern);
ZEPHIR_CONCAT_SVSVVSVS(pattern, "/", ld_s, "([^", ld_s, rd_s, "]+)", rd_s, "/");
ZEPHIR_CPY_WRT(result, text);
while (1) {
if (!(zephir_memnstr(result, leftDelimiter, "phalcon/text.zep", 273))) {
break;
}
ZEPHIR_INIT_NVAR(_3);
ZEPHIR_INIT_NVAR(_3);
zephir_create_closure_ex(_3, NULL, phalcon_0__closure_ce, SS("__invoke") TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_6, "preg_replace_callback", &_7, 423, pattern, _3, result);
zephir_check_call_status();
ZEPHIR_CPY_WRT(result, _6);
}
RETURN_CCTOR(result);
}
/**
* Executes the validation
*
* @param Phalcon\Validation validation
* @param string field
* @return boolean
*/
PHP_METHOD(Phalcon_Validation_Validator_Identical, validate) {
zephir_nts_static zephir_fcall_cache_entry *_4 = NULL, *_6 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *field = NULL;
zval *validation, *field_param = NULL, *message = NULL, *label = NULL, *replacePairs, *_0 = NULL, *_1 = NULL, *_2 = NULL, *_3 = NULL, *_5;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &validation, &field_param);
if (unlikely(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 (likely(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(&_0, validation, "getvalue", NULL, field);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_2);
ZVAL_STRING(_2, "value", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_1, this_ptr, "getoption", NULL, _2);
zephir_check_temp_parameter(_2);
zephir_check_call_status();
if (!ZEPHIR_IS_EQUAL(_0, _1)) {
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "label", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&label, this_ptr, "getoption", NULL, _2);
zephir_check_temp_parameter(_2);
zephir_check_call_status();
if (ZEPHIR_IS_EMPTY(label)) {
ZEPHIR_CALL_METHOD(&label, validation, "getlabel", NULL, field);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "message", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, _2);
zephir_check_temp_parameter(_2);
zephir_check_call_status();
ZEPHIR_INIT_VAR(replacePairs);
zephir_create_array(replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "Identical", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, _2);
zephir_check_temp_parameter(_2);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_3, "strtr", &_4, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_5);
ZVAL_STRING(_5, "Identical", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", &_6, _3, field, _5);
zephir_check_temp_parameter(_5);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, _2);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
/**
* Produces a pre-computed hash key based on a string. This function produces different numbers in 32bit/64bit processors
*
* @param string key
* @return string
*/
PHP_METHOD(Phalcon_Kernel, preComputeHashKey) {
zval *key_param = NULL;
zval *key = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &key_param);
if (unlikely(Z_TYPE_P(key_param) != IS_STRING && Z_TYPE_P(key_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'key' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(key_param) == IS_STRING)) {
zephir_get_strval(key, key_param);
} else {
ZEPHIR_INIT_VAR(key);
ZVAL_EMPTY_STRING(key);
}
{
char *arKey = Z_STRVAL_P(key), *strKey;
int nKeyLength = strlen(arKey);
register ulong hash = 5381;
nKeyLength++;
/* variant with the hash unrolled eight times */
for (; nKeyLength >= 8; nKeyLength -= 8) {
hash = ((hash << 5) + hash) + *arKey++;
hash = ((hash << 5) + hash) + *arKey++;
hash = ((hash << 5) + hash) + *arKey++;
hash = ((hash << 5) + hash) + *arKey++;
hash = ((hash << 5) + hash) + *arKey++;
hash = ((hash << 5) + hash) + *arKey++;
hash = ((hash << 5) + hash) + *arKey++;
hash = ((hash << 5) + hash) + *arKey++;
}
switch (nKeyLength) {
case 7: hash = ((hash << 5) + hash) + *arKey++;
/* no break */
case 6: hash = ((hash << 5) + hash) + *arKey++;
/* no break */
case 5: hash = ((hash << 5) + hash) + *arKey++;
/* no break */
case 4: hash = ((hash << 5) + hash) + *arKey++;
/* no break */
case 3: hash = ((hash << 5) + hash) + *arKey++;
/* no break */
case 2: hash = ((hash << 5) + hash) + *arKey++;
/* no break */
case 1: hash = ((hash << 5) + hash) + *arKey++; break;
}
strKey = emalloc(24);
snprintf(strKey, 24, "%lu", hash);
RETURN_MM_STRING(strKey, 0);
}
ZEPHIR_MM_RESTORE();
}
/**
* Replaces placeholders from pattern returning a valid PCRE regular expression
*/
PHP_METHOD(Phalcon_Mvc_Router_Route, compilePattern) {
zval *pattern_param = NULL, *idPattern = NULL, *_0$$4, _1$$4, *_2$$5, _3$$5, *_4$$6, _5$$6, *_6$$7, _7$$7, *_8$$8, _9$$8, _10$$8, *_11$$9, _12$$9, _13$$9;
zval *pattern = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &pattern_param);
if (unlikely(Z_TYPE_P(pattern_param) != IS_STRING && Z_TYPE_P(pattern_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'pattern' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(pattern_param) == IS_STRING)) {
zephir_get_strval(pattern, pattern_param);
} else {
ZEPHIR_INIT_VAR(pattern);
ZVAL_EMPTY_STRING(pattern);
}
if (zephir_memnstr_str(pattern, SL(":"), "phalcon/mvc/router/route.zep", 87)) {
ZEPHIR_INIT_VAR(idPattern);
ZVAL_STRING(idPattern, "/([a-zA-Z0-9\\_\\-]+)", 1);
if (zephir_memnstr_str(pattern, SL("/:module"), "phalcon/mvc/router/route.zep", 93)) {
ZEPHIR_INIT_VAR(_0$$4);
ZEPHIR_SINIT_VAR(_1$$4);
ZVAL_STRING(&_1$$4, "/:module", 0);
zephir_fast_str_replace(&_0$$4, &_1$$4, idPattern, pattern TSRMLS_CC);
zephir_get_strval(pattern, _0$$4);
}
if (zephir_memnstr_str(pattern, SL("/:controller"), "phalcon/mvc/router/route.zep", 98)) {
ZEPHIR_INIT_VAR(_2$$5);
ZEPHIR_SINIT_VAR(_3$$5);
ZVAL_STRING(&_3$$5, "/:controller", 0);
zephir_fast_str_replace(&_2$$5, &_3$$5, idPattern, pattern TSRMLS_CC);
zephir_get_strval(pattern, _2$$5);
}
if (zephir_memnstr_str(pattern, SL("/:namespace"), "phalcon/mvc/router/route.zep", 103)) {
ZEPHIR_INIT_VAR(_4$$6);
ZEPHIR_SINIT_VAR(_5$$6);
ZVAL_STRING(&_5$$6, "/:namespace", 0);
zephir_fast_str_replace(&_4$$6, &_5$$6, idPattern, pattern TSRMLS_CC);
zephir_get_strval(pattern, _4$$6);
}
if (zephir_memnstr_str(pattern, SL("/:action"), "phalcon/mvc/router/route.zep", 108)) {
ZEPHIR_INIT_VAR(_6$$7);
ZEPHIR_SINIT_VAR(_7$$7);
ZVAL_STRING(&_7$$7, "/:action", 0);
zephir_fast_str_replace(&_6$$7, &_7$$7, idPattern, pattern TSRMLS_CC);
zephir_get_strval(pattern, _6$$7);
}
if (zephir_memnstr_str(pattern, SL("/:params"), "phalcon/mvc/router/route.zep", 113)) {
ZEPHIR_INIT_VAR(_8$$8);
ZEPHIR_SINIT_VAR(_9$$8);
ZVAL_STRING(&_9$$8, "/:params", 0);
ZEPHIR_SINIT_VAR(_10$$8);
ZVAL_STRING(&_10$$8, "(/.*)*", 0);
zephir_fast_str_replace(&_8$$8, &_9$$8, &_10$$8, pattern TSRMLS_CC);
zephir_get_strval(pattern, _8$$8);
}
if (zephir_memnstr_str(pattern, SL("/:int"), "phalcon/mvc/router/route.zep", 118)) {
ZEPHIR_INIT_VAR(_11$$9);
ZEPHIR_SINIT_VAR(_12$$9);
ZVAL_STRING(&_12$$9, "/:int", 0);
ZEPHIR_SINIT_VAR(_13$$9);
ZVAL_STRING(&_13$$9, "/([0-9]+)", 0);
zephir_fast_str_replace(&_11$$9, &_12$$9, &_13$$9, pattern TSRMLS_CC);
zephir_get_strval(pattern, _11$$9);
}
}
if (zephir_memnstr_str(pattern, SL("("), "phalcon/mvc/router/route.zep", 124)) {
ZEPHIR_CONCAT_SVS(return_value, "#^", pattern, "$#");
RETURN_MM();
}
if (zephir_memnstr_str(pattern, SL("["), "phalcon/mvc/router/route.zep", 129)) {
ZEPHIR_CONCAT_SVS(return_value, "#^", pattern, "$#");
RETURN_MM();
}
RETURN_CTOR(pattern);
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_Url, validate) {
zend_bool _2;
int ZEPHIR_LAST_CALL_STATUS;
zval *field = NULL;
zval *validation, *field_param = NULL, *value = NULL, *message = NULL, *label = NULL, *replacePairs, *_0 = NULL, *_1 = NULL, _3, *_4 = NULL, *_5 = NULL, *_6;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &validation, &field_param);
if (unlikely(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 (likely(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_INIT_VAR(_1);
ZVAL_STRING(_1, "allowEmpty", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "issetoption", NULL, 0, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
_2 = zephir_is_true(_0);
if (_2) {
_2 = ZEPHIR_IS_EMPTY(value);
}
if (_2) {
RETURN_MM_BOOL(1);
}
ZEPHIR_SINIT_VAR(_3);
ZVAL_LONG(&_3, 273);
ZEPHIR_CALL_FUNCTION(&_4, "filter_var", NULL, 191, value, &_3);
zephir_check_call_status();
if (!(zephir_is_true(_4))) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "label", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&label, this_ptr, "getoption", NULL, 0, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
if (ZEPHIR_IS_EMPTY(label)) {
ZEPHIR_CALL_METHOD(&label, validation, "getlabel", NULL, 0, field);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "message", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
ZEPHIR_INIT_VAR(replacePairs);
zephir_create_array(replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "Url", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_1);
object_init_ex(_1, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_5, "strtr", NULL, 53, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_6);
ZVAL_STRING(_6, "Url", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, 436, _5, field, _6);
zephir_check_temp_parameter(_6);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _1);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
/**
* Phalcon\Db\Column constructor
*/
PHP_METHOD(Phalcon_Db_Column, __construct) {
zval *definition = NULL;
zval *name_param = NULL, *definition_param = NULL, *type = NULL, *notNull = NULL, *primary = NULL, *size = NULL, *scale = NULL, *dunsigned = NULL, *first = NULL, *after = NULL, *bindType = NULL, *isNumeric = NULL, *autoIncrement = NULL, *defaultValue = NULL, *typeReference = NULL, *typeValues = NULL;
zval *name = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &name_param, &definition_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);
}
definition = definition_param;
zephir_update_property_this(getThis(), SL("_name"), name TSRMLS_CC);
ZEPHIR_OBS_VAR(type);
if (zephir_array_isset_string_fetch(&type, definition, SS("type"), 0 TSRMLS_CC)) {
zephir_update_property_this(getThis(), SL("_type"), type TSRMLS_CC);
} else {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "Column type is required", "phalcon/db/column.zep", 299);
return;
}
ZEPHIR_OBS_VAR(typeReference);
if (zephir_array_isset_string_fetch(&typeReference, definition, SS("typeReference"), 0 TSRMLS_CC)) {
zephir_update_property_this(getThis(), SL("_typeReference"), typeReference TSRMLS_CC);
}
ZEPHIR_OBS_VAR(typeValues);
if (zephir_array_isset_string_fetch(&typeValues, definition, SS("typeValues"), 0 TSRMLS_CC)) {
zephir_update_property_this(getThis(), SL("_typeValues"), typeValues TSRMLS_CC);
}
ZEPHIR_OBS_VAR(notNull);
if (zephir_array_isset_string_fetch(¬Null, definition, SS("notNull"), 0 TSRMLS_CC)) {
zephir_update_property_this(getThis(), SL("_notNull"), notNull TSRMLS_CC);
}
ZEPHIR_OBS_VAR(primary);
if (zephir_array_isset_string_fetch(&primary, definition, SS("primary"), 0 TSRMLS_CC)) {
zephir_update_property_this(getThis(), SL("_primary"), primary TSRMLS_CC);
}
ZEPHIR_OBS_VAR(size);
if (zephir_array_isset_string_fetch(&size, definition, SS("size"), 0 TSRMLS_CC)) {
zephir_update_property_this(getThis(), SL("_size"), size TSRMLS_CC);
}
ZEPHIR_OBS_VAR(scale);
if (zephir_array_isset_string_fetch(&scale, definition, SS("scale"), 0 TSRMLS_CC)) {
do {
if (ZEPHIR_IS_LONG(type, 0) || ZEPHIR_IS_LONG(type, 7) || ZEPHIR_IS_LONG(type, 3) || ZEPHIR_IS_LONG(type, 9) || ZEPHIR_IS_LONG(type, 14)) {
zephir_update_property_this(getThis(), SL("_scale"), scale TSRMLS_CC);
break;
}
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "Column type does not support scale parameter", "phalcon/db/column.zep", 343);
return;
} while(0);
}
ZEPHIR_OBS_VAR(defaultValue);
if (zephir_array_isset_string_fetch(&defaultValue, definition, SS("default"), 0 TSRMLS_CC)) {
zephir_update_property_this(getThis(), SL("_default"), defaultValue TSRMLS_CC);
}
ZEPHIR_OBS_VAR(dunsigned);
if (zephir_array_isset_string_fetch(&dunsigned, definition, SS("unsigned"), 0 TSRMLS_CC)) {
zephir_update_property_this(getThis(), SL("_unsigned"), dunsigned TSRMLS_CC);
}
ZEPHIR_OBS_VAR(isNumeric);
if (zephir_array_isset_string_fetch(&isNumeric, definition, SS("isNumeric"), 0 TSRMLS_CC)) {
zephir_update_property_this(getThis(), SL("_isNumeric"), isNumeric TSRMLS_CC);
}
ZEPHIR_OBS_VAR(autoIncrement);
if (zephir_array_isset_string_fetch(&autoIncrement, definition, SS("autoIncrement"), 0 TSRMLS_CC)) {
if (!(zephir_is_true(autoIncrement))) {
if (0) {
zephir_update_property_this(getThis(), SL("_autoIncrement"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
} else {
zephir_update_property_this(getThis(), SL("_autoIncrement"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
}
} else {
do {
if (ZEPHIR_IS_LONG(type, 0) || ZEPHIR_IS_LONG(type, 14)) {
if (1) {
zephir_update_property_this(getThis(), SL("_autoIncrement"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
} else {
zephir_update_property_this(getThis(), SL("_autoIncrement"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
}
break;
}
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "Column type cannot be auto-increment", "phalcon/db/column.zep", 383);
return;
} while(0);
}
}
if (zephir_array_isset_string_fetch(&first, definition, SS("first"), 1 TSRMLS_CC)) {
zephir_update_property_this(getThis(), SL("_first"), first TSRMLS_CC);
}
if (zephir_array_isset_string_fetch(&after, definition, SS("after"), 1 TSRMLS_CC)) {
zephir_update_property_this(getThis(), SL("_after"), after TSRMLS_CC);
}
if (zephir_array_isset_string_fetch(&bindType, definition, SS("bindType"), 1 TSRMLS_CC)) {
zephir_update_property_this(getThis(), SL("_bindType"), bindType TSRMLS_CC);
}
ZEPHIR_MM_RESTORE();
}
/**
* Internal sanitize wrapper to filter_var
*/
PHP_METHOD(Phalcon_Filter, _sanitize) {
zephir_fcall_cache_entry *_5 = NULL;
zval *_2 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zend_bool _1;
zval *filter = NULL, *_8;
zval *value, *filter_param = NULL, *filterObject, *_0, _3 = zval_used_for_init, *_4 = NULL, *_6 = NULL, *_7;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &value, &filter_param);
if (unlikely(Z_TYPE_P(filter_param) != IS_STRING && Z_TYPE_P(filter_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'filter' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(filter_param) == IS_STRING)) {
zephir_get_strval(filter, filter_param);
} else {
ZEPHIR_INIT_VAR(filter);
ZVAL_EMPTY_STRING(filter);
}
ZEPHIR_OBS_VAR(filterObject);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_filters"), PH_NOISY_CC);
if (zephir_array_isset_fetch(&filterObject, _0, filter, 0 TSRMLS_CC)) {
_1 = zephir_instance_of_ev(filterObject, zend_ce_closure TSRMLS_CC);
if (!(_1)) {
_1 = zephir_is_callable(filterObject TSRMLS_CC);
}
if (_1) {
ZEPHIR_INIT_VAR(_2);
zephir_create_array(_2, 1, 0 TSRMLS_CC);
zephir_array_fast_append(_2, value);
ZEPHIR_CALL_USER_FUNC_ARRAY(return_value, filterObject, _2);
zephir_check_call_status();
RETURN_MM();
}
ZEPHIR_RETURN_CALL_METHOD(filterObject, "filter", NULL, 0, value);
zephir_check_call_status();
RETURN_MM();
}
do {
if (ZEPHIR_IS_STRING(filter, "email")) {
ZEPHIR_SINIT_VAR(_3);
ZVAL_STRING(&_3, "FILTER_SANITIZE_EMAIL", 0);
ZEPHIR_CALL_FUNCTION(&_4, "constant", NULL, 189, &_3);
zephir_check_call_status();
ZEPHIR_RETURN_CALL_FUNCTION("filter_var", &_5, 190, value, _4);
zephir_check_call_status();
RETURN_MM();
}
if (ZEPHIR_IS_STRING(filter, "int")) {
ZEPHIR_SINIT_NVAR(_3);
ZVAL_LONG(&_3, 519);
ZEPHIR_RETURN_CALL_FUNCTION("filter_var", &_5, 190, value, &_3);
zephir_check_call_status();
RETURN_MM();
}
if (ZEPHIR_IS_STRING(filter, "int!")) {
RETURN_MM_LONG(zephir_get_intval(value));
}
if (ZEPHIR_IS_STRING(filter, "absint")) {
ZEPHIR_SINIT_NVAR(_3);
ZVAL_LONG(&_3, zephir_get_intval(value));
ZEPHIR_RETURN_CALL_FUNCTION("abs", NULL, 191, &_3);
zephir_check_call_status();
RETURN_MM();
}
if (ZEPHIR_IS_STRING(filter, "string")) {
ZEPHIR_SINIT_NVAR(_3);
ZVAL_LONG(&_3, 513);
ZEPHIR_RETURN_CALL_FUNCTION("filter_var", &_5, 190, value, &_3);
zephir_check_call_status();
RETURN_MM();
}
if (ZEPHIR_IS_STRING(filter, "float")) {
ZEPHIR_INIT_NVAR(_2);
zephir_create_array(_2, 1, 0 TSRMLS_CC);
add_assoc_long_ex(_2, SS("flags"), 4096);
ZEPHIR_SINIT_NVAR(_3);
ZVAL_LONG(&_3, 520);
ZEPHIR_RETURN_CALL_FUNCTION("filter_var", &_5, 190, value, &_3, _2);
zephir_check_call_status();
RETURN_MM();
}
if (ZEPHIR_IS_STRING(filter, "float!")) {
RETURN_MM_DOUBLE(zephir_get_doubleval(value));
}
if (ZEPHIR_IS_STRING(filter, "alphanum")) {
ZEPHIR_INIT_VAR(_6);
ZVAL_STRING(_6, "/[^A-Za-z0-9]/", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_7);
ZVAL_STRING(_7, "", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_RETURN_CALL_FUNCTION("preg_replace", NULL, 28, _6, _7, value);
zephir_check_temp_parameter(_6);
zephir_check_temp_parameter(_7);
zephir_check_call_status();
RETURN_MM();
}
if (ZEPHIR_IS_STRING(filter, "trim")) {
zephir_fast_trim(return_value, value, NULL , ZEPHIR_TRIM_BOTH TSRMLS_CC);
RETURN_MM();
}
if (ZEPHIR_IS_STRING(filter, "striptags")) {
ZEPHIR_RETURN_CALL_FUNCTION("strip_tags", NULL, 192, value);
zephir_check_call_status();
RETURN_MM();
}
if (ZEPHIR_IS_STRING(filter, "lower")) {
if ((zephir_function_exists_ex(SS("mb_strtolower") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_RETURN_CALL_FUNCTION("mb_strtolower", NULL, 193, value);
zephir_check_call_status();
RETURN_MM();
}
zephir_fast_strtolower(return_value, value);
RETURN_MM();
}
if (ZEPHIR_IS_STRING(filter, "upper")) {
if ((zephir_function_exists_ex(SS("mb_strtoupper") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_RETURN_CALL_FUNCTION("mb_strtoupper", NULL, 194, value);
zephir_check_call_status();
RETURN_MM();
}
zephir_fast_strtoupper(return_value, value);
RETURN_MM();
}
ZEPHIR_INIT_NVAR(_6);
object_init_ex(_6, phalcon_filter_exception_ce);
ZEPHIR_INIT_VAR(_8);
ZEPHIR_CONCAT_SVS(_8, "Sanitize filter '", filter, "' is not supported");
ZEPHIR_CALL_METHOD(NULL, _6, "__construct", NULL, 9, _8);
zephir_check_call_status();
zephir_throw_exception_debug(_6, "phalcon/filter.zep", 213 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
} while(0);
ZEPHIR_MM_RESTORE();
}
/**
* Magic method __get
*/
PHP_METHOD(Phalcon_Di_Injectable, __get) {
zval *_4;
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_1 = NULL;
zval *propertyName_param = NULL, *dependencyInjector = NULL, *service = NULL, *persistent = NULL, *_0, *_2 = NULL, *_3 = NULL, *_5 = NULL;
zval *propertyName = NULL, *_6;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &propertyName_param);
if (unlikely(Z_TYPE_P(propertyName_param) != IS_STRING && Z_TYPE_P(propertyName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'propertyName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(propertyName_param) == IS_STRING)) {
zephir_get_strval(propertyName, propertyName_param);
} else {
ZEPHIR_INIT_VAR(propertyName);
ZVAL_EMPTY_STRING(propertyName);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(dependencyInjector, _0);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_CALL_CE_STATIC(&dependencyInjector, phalcon_di_ce, "getdefault", &_1, 1);
zephir_check_call_status();
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_di_exception_ce, "A dependency injection object is required to access the application services", "phalcon/di/injectable.zep", 127);
return;
}
}
ZEPHIR_CALL_METHOD(&_2, dependencyInjector, "has", NULL, 0, propertyName);
zephir_check_call_status();
if (zephir_is_true(_2)) {
ZEPHIR_CALL_METHOD(&service, dependencyInjector, "getshared", NULL, 0, propertyName);
zephir_check_call_status();
zephir_update_property_zval_zval(this_ptr, propertyName, service TSRMLS_CC);
RETURN_CCTOR(service);
}
if (ZEPHIR_IS_STRING(propertyName, "di")) {
zephir_update_property_zval(this_ptr, SL("di"), dependencyInjector TSRMLS_CC);
RETURN_CCTOR(dependencyInjector);
}
if (ZEPHIR_IS_STRING(propertyName, "persistent")) {
ZEPHIR_INIT_VAR(_4);
zephir_create_array(_4, 1, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_5);
zephir_get_class(_5, this_ptr, 0 TSRMLS_CC);
zephir_array_fast_append(_4, _5);
ZEPHIR_INIT_NVAR(_5);
ZVAL_STRING(_5, "sessionBag", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_3, dependencyInjector, "get", NULL, 0, _5, _4);
zephir_check_temp_parameter(_5);
zephir_check_call_status();
ZEPHIR_CPY_WRT(persistent, _3);
zephir_update_property_zval(this_ptr, SL("persistent"), persistent TSRMLS_CC);
RETURN_CCTOR(persistent);
}
ZEPHIR_INIT_VAR(_6);
ZEPHIR_CONCAT_SV(_6, "Access to undefined property ", propertyName);
ZEPHIR_CALL_FUNCTION(NULL, "trigger_error", NULL, 2, _6);
zephir_check_call_status();
RETURN_MM_NULL();
}
/**
* Executes the validation
*
* @param Phalcon\Validation validation
* @param string field
* @return boolean
*/
PHP_METHOD(Phalcon_Validation_Validator_File, validate) {
zephir_nts_static zephir_fcall_cache_entry *_10 = NULL, *_12 = NULL, *_22 = NULL, *_28 = NULL, *_30 = NULL, *_39 = NULL;
zend_bool _2, _3, _4, _6, _7, _13, _14, _15, _17, _18, _20, _25, _26, _38, _40, _42;
int ZEPHIR_LAST_CALL_STATUS;
zval *field = NULL;
zval *validation, *field_param = NULL, *value = NULL, *message = NULL, *label = NULL, *replacePairs = NULL, *types = NULL, *byteUnits, *unit = NULL, *maxSize = NULL, *matches, *bytes, *mime = NULL, *tmp = NULL, *width, *height, *minResolution, *maxResolution, *minWidth = NULL, *maxWidth, *minHeight = NULL, *maxHeight, *_0 = NULL, *_SERVER, *_1, *_POST, *_FILES, *_5, *_8, *_9 = NULL, *_11 = NULL, *_16, *_19, *_21, *_23 = NULL, *_24 = NULL, *_27, *_29, *_31 = NULL, *_32, _33 = zval_used_for_init, *_34, *_35 = NULL, *_36 = NULL, *_37, *_41 = NULL, *_43 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &validation, &field_param);
if (unlikely(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 (likely(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, field);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "label", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&label, this_ptr, "getoption", NULL, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (ZEPHIR_IS_EMPTY(label)) {
ZEPHIR_CALL_METHOD(&label, validation, "getlabel", NULL, field);
zephir_check_call_status();
}
zephir_get_global(&_SERVER, SS("_SERVER") TSRMLS_CC);
zephir_array_fetch_string(&_1, _SERVER, SL("REQUEST_METHOD"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 64 TSRMLS_CC);
_2 = ZEPHIR_IS_STRING(_1, "POST");
if (_2) {
zephir_get_global(&_POST, SS("_POST") TSRMLS_CC);
_2 = ZEPHIR_IS_EMPTY(_POST);
}
_3 = _2;
if (_3) {
zephir_get_global(&_FILES, SS("_FILES") TSRMLS_CC);
_3 = ZEPHIR_IS_EMPTY(_FILES);
}
_4 = _3;
if (_4) {
zephir_array_fetch_string(&_5, _SERVER, SL("CONTENT_LENGTH"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 64 TSRMLS_CC);
_4 = ZEPHIR_GT_LONG(_5, 0);
}
_6 = _4;
if (!(_6)) {
_7 = zephir_array_isset_string(value, SS("error"));
if (_7) {
zephir_array_fetch_string(&_8, value, SL("error"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 64 TSRMLS_CC);
_7 = ZEPHIR_IS_LONG_IDENTICAL(_8, 1);
}
_6 = _7;
}
if (_6) {
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "messageIniSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(replacePairs);
zephir_create_array(replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "FileIniSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_0);
object_init_ex(_0, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_9, "strtr", &_10, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_11);
ZVAL_STRING(_11, "FileIniSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _0, "__construct", &_12, _9, field, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, _0);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "allowEmpty", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_9, this_ptr, "issetoption", NULL, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
_13 = zephir_is_true(_9);
if (_13) {
_14 = ZEPHIR_IS_EMPTY(value);
if (!(_14)) {
_15 = zephir_array_isset_string(value, SS("error"));
if (_15) {
zephir_array_fetch_string(&_16, value, SL("error"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 76 TSRMLS_CC);
_15 = ZEPHIR_IS_LONG_IDENTICAL(_16, 4);
}
_14 = _15;
}
_13 = _14;
}
if (_13) {
RETURN_MM_BOOL(1);
}
_17 = !(zephir_array_isset_string(value, SS("error")));
if (!(_17)) {
_17 = !(zephir_array_isset_string(value, SS("tmp_name")));
}
_18 = _17;
if (!(_18)) {
zephir_array_fetch_string(&_19, value, SL("error"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 80 TSRMLS_CC);
_18 = !ZEPHIR_IS_LONG_IDENTICAL(_19, 0);
}
_20 = _18;
if (!(_20)) {
zephir_array_fetch_string(&_21, value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 80 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_9, "is_uploaded_file", &_22, _21);
zephir_check_call_status();
_20 = !zephir_is_true(_9);
}
if (_20) {
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "messageEmpty", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(replacePairs);
zephir_create_array(replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "FileEmpty", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_11);
object_init_ex(_11, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_23, "strtr", &_10, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_24);
ZVAL_STRING(_24, "FileEmpty", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _11, "__construct", &_12, _23, field, _24);
zephir_check_temp_parameter(_24);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, _11);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
_25 = !(zephir_array_isset_string(value, SS("name")));
if (!(_25)) {
_25 = !(zephir_array_isset_string(value, SS("type")));
}
_26 = _25;
if (!(_26)) {
_26 = !(zephir_array_isset_string(value, SS("size")));
}
if (_26) {
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "messageValid", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(replacePairs);
zephir_create_array(replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "FileValid", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_11);
object_init_ex(_11, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_9, "strtr", &_10, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_24);
ZVAL_STRING(_24, "FileValid", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _11, "__construct", &_12, _9, field, _24);
zephir_check_temp_parameter(_24);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, _11);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "maxSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_9, this_ptr, "issetoption", NULL, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
if (zephir_is_true(_9)) {
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_NVAR(_11);
ZVAL_STRING(_11, "maxSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&maxSize, this_ptr, "getoption", NULL, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
ZEPHIR_INIT_VAR(matches);
ZVAL_NULL(matches);
ZEPHIR_INIT_VAR(unit);
ZVAL_STRING(unit, "B", 1);
ZEPHIR_INIT_NVAR(_11);
ZEPHIR_INIT_NVAR(_24);
zephir_array_keys(_24, byteUnits TSRMLS_CC);
zephir_fast_join_str(_11, SL("|"), _24 TSRMLS_CC);
ZEPHIR_INIT_VAR(_27);
ZEPHIR_CONCAT_SVS(_27, "/^([0-9]+(?:\\.[0-9]+)?)(", _11, ")?$/Di");
Z_SET_ISREF_P(matches);
ZEPHIR_CALL_FUNCTION(NULL, "preg_match", &_28, _27, maxSize, matches);
Z_UNSET_ISREF_P(matches);
zephir_check_call_status();
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", 113 TSRMLS_CC);
}
zephir_array_fetch_long(&_29, matches, 1, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 116 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_23, "floatval", &_30, _29);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_31);
zephir_array_fetch(&_32, byteUnits, unit, PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 116 TSRMLS_CC);
ZEPHIR_SINIT_VAR(_33);
ZVAL_LONG(&_33, 2);
zephir_pow_function(_31, &_33, _32);
ZEPHIR_INIT_VAR(bytes);
mul_function(bytes, _23, _31 TSRMLS_CC);
zephir_array_fetch_string(&_34, value, SL("size"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 118 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_23, "floatval", &_30, _34);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&_35, "floatval", &_30, bytes);
zephir_check_call_status();
if (ZEPHIR_GT(_23, _35)) {
ZEPHIR_INIT_NVAR(_31);
ZVAL_STRING(_31, "messageSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, _31);
zephir_check_temp_parameter(_31);
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"), &maxSize, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(_31);
ZVAL_STRING(_31, "FileSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, _31);
zephir_check_temp_parameter(_31);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_31);
object_init_ex(_31, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_36, "strtr", &_10, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_37);
ZVAL_STRING(_37, "FileSize", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _31, "__construct", &_12, _36, field, _37);
zephir_check_temp_parameter(_37);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, _31);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "allowedTypes", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_9, this_ptr, "issetoption", NULL, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
if (zephir_is_true(_9)) {
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "allowedTypes", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&types, this_ptr, "getoption", NULL, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
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", 135);
return;
}
if ((zephir_function_exists_ex(SS("finfo_open") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_SINIT_NVAR(_33);
ZVAL_LONG(&_33, 16);
ZEPHIR_CALL_FUNCTION(&tmp, "finfo_open", NULL, &_33);
zephir_check_call_status();
zephir_array_fetch_string(&_29, value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 140 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&mime, "finfo_file", NULL, tmp, _29);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(NULL, "finfo_close", NULL, 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", 144 TSRMLS_CC);
}
if (!(zephir_fast_in_array(mime, types TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "messageType", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, _11);
zephir_check_temp_parameter(_11);
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_INIT_NVAR(_11);
zephir_fast_join_str(_11, SL(", "), types TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":types"), &_11, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "FileType", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_11);
object_init_ex(_11, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_23, "strtr", &_10, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_24);
ZVAL_STRING(_24, "FileType", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _11, "__construct", &_12, _23, field, _24);
zephir_check_temp_parameter(_24);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, _11);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "minResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_9, this_ptr, "issetoption", NULL, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
_38 = zephir_is_true(_9);
if (!(_38)) {
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "maxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_23, this_ptr, "issetoption", NULL, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
_38 = zephir_is_true(_23);
}
if (_38) {
zephir_array_fetch_string(&_29, value, SL("tmp_name"), PH_NOISY | PH_READONLY, "phalcon/validation/validator/file.zep", 161 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&tmp, "getimagesize", &_39, _29);
zephir_check_call_status();
ZEPHIR_OBS_VAR(width);
zephir_array_fetch_long(&width, tmp, 0, PH_NOISY, "phalcon/validation/validator/file.zep", 162 TSRMLS_CC);
ZEPHIR_OBS_VAR(height);
zephir_array_fetch_long(&height, tmp, 1, PH_NOISY, "phalcon/validation/validator/file.zep", 163 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "minResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_35, this_ptr, "issetoption", NULL, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
if (zephir_is_true(_35)) {
ZEPHIR_INIT_VAR(minResolution);
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "minResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_36, this_ptr, "getoption", NULL, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
zephir_fast_explode_str(minResolution, SL("x"), _36, LONG_MAX TSRMLS_CC);
ZEPHIR_OBS_VAR(minWidth);
zephir_array_fetch_long(&minWidth, minResolution, 0, PH_NOISY, "phalcon/validation/validator/file.zep", 167 TSRMLS_CC);
ZEPHIR_OBS_VAR(minHeight);
zephir_array_fetch_long(&minHeight, minResolution, 1, PH_NOISY, "phalcon/validation/validator/file.zep", 168 TSRMLS_CC);
} else {
ZEPHIR_INIT_NVAR(minWidth);
ZVAL_LONG(minWidth, 1);
ZEPHIR_INIT_NVAR(minHeight);
ZVAL_LONG(minHeight, 1);
}
_40 = ZEPHIR_LT(width, minWidth);
if (!(_40)) {
_40 = ZEPHIR_LT(height, minHeight);
}
if (_40) {
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "messageMinResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, _11);
zephir_check_temp_parameter(_11);
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_INIT_NVAR(_11);
ZVAL_STRING(_11, "minResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_36, this_ptr, "getoption", NULL, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
zephir_array_update_string(&replacePairs, SL(":min"), &_36, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(_11);
ZVAL_STRING(_11, "FileMinResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, _11);
zephir_check_temp_parameter(_11);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_11);
object_init_ex(_11, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_36, "strtr", &_10, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_24);
ZVAL_STRING(_24, "FileMinResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _11, "__construct", &_12, _36, field, _24);
zephir_check_temp_parameter(_24);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, _11);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_NVAR(_24);
ZVAL_STRING(_24, "maxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_36, this_ptr, "issetoption", NULL, _24);
zephir_check_temp_parameter(_24);
zephir_check_call_status();
if (zephir_is_true(_36)) {
ZEPHIR_INIT_VAR(maxResolution);
ZEPHIR_INIT_NVAR(_24);
ZVAL_STRING(_24, "maxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_41, this_ptr, "getoption", NULL, _24);
zephir_check_temp_parameter(_24);
zephir_check_call_status();
zephir_fast_explode_str(maxResolution, SL("x"), _41, LONG_MAX TSRMLS_CC);
ZEPHIR_OBS_VAR(maxWidth);
zephir_array_fetch_long(&maxWidth, maxResolution, 0, PH_NOISY, "phalcon/validation/validator/file.zep", 189 TSRMLS_CC);
ZEPHIR_OBS_VAR(maxHeight);
zephir_array_fetch_long(&maxHeight, maxResolution, 1, PH_NOISY, "phalcon/validation/validator/file.zep", 190 TSRMLS_CC);
_42 = ZEPHIR_GT(width, maxWidth);
if (!(_42)) {
_42 = ZEPHIR_GT(height, maxHeight);
}
if (_42) {
ZEPHIR_INIT_NVAR(_24);
ZVAL_STRING(_24, "messageMaxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, _24);
zephir_check_temp_parameter(_24);
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_INIT_NVAR(_24);
ZVAL_STRING(_24, "maxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_43, this_ptr, "getoption", NULL, _24);
zephir_check_temp_parameter(_24);
zephir_check_call_status();
zephir_array_update_string(&replacePairs, SL(":max"), &_43, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(_24);
ZVAL_STRING(_24, "FileMaxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, _24);
zephir_check_temp_parameter(_24);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_24);
object_init_ex(_24, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_43, "strtr", &_10, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_31);
ZVAL_STRING(_31, "FileMaxResolution", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _24, "__construct", &_12, _43, field, _31);
zephir_check_temp_parameter(_31);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, _24);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
}
RETURN_MM_BOOL(1);
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_Alnum, validate) {
int ZEPHIR_LAST_CALL_STATUS;
zval *field = NULL;
zval *validation, *field_param = NULL, *value = NULL, *message = NULL, *label = NULL, *replacePairs = NULL, *code = NULL, *_0 = NULL, *_1$$3 = NULL, *_6$$3 = NULL, *_7$$3, *_2$$4, *_3$$6, *_4$$7, *_5$$8;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &validation, &field_param);
if (unlikely(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 (likely(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_FUNCTION(&_0, "ctype_alnum", NULL, 467, value);
zephir_check_call_status();
if (!(zephir_is_true(_0))) {
ZEPHIR_INIT_VAR(_1$$3);
ZVAL_STRING(_1$$3, "label", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&label, this_ptr, "getoption", NULL, 0, _1$$3);
zephir_check_temp_parameter(_1$$3);
zephir_check_call_status();
if (Z_TYPE_P(label) == IS_ARRAY) {
zephir_array_fetch(&_2$$4, label, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/alnum.zep", 75 TSRMLS_CC);
ZEPHIR_CPY_WRT(label, _2$$4);
}
if (ZEPHIR_IS_EMPTY(label)) {
ZEPHIR_CALL_METHOD(&label, validation, "getlabel", NULL, 0, field);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_1$$3);
ZVAL_STRING(_1$$3, "message", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _1$$3);
zephir_check_temp_parameter(_1$$3);
zephir_check_call_status();
if (Z_TYPE_P(message) == IS_ARRAY) {
zephir_array_fetch(&_3$$6, message, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/alnum.zep", 83 TSRMLS_CC);
ZEPHIR_CPY_WRT(message, _3$$6);
}
ZEPHIR_INIT_VAR(replacePairs);
zephir_create_array(replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_VAR(_4$$7);
ZVAL_STRING(_4$$7, "Alnum", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _4$$7);
zephir_check_temp_parameter(_4$$7);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_1$$3);
ZVAL_STRING(_1$$3, "code", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&code, this_ptr, "getoption", NULL, 0, _1$$3);
zephir_check_temp_parameter(_1$$3);
zephir_check_call_status();
if (Z_TYPE_P(code) == IS_ARRAY) {
zephir_array_fetch(&_5$$8, code, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/alnum.zep", 93 TSRMLS_CC);
ZEPHIR_CPY_WRT(code, _5$$8);
}
ZEPHIR_INIT_NVAR(_1$$3);
object_init_ex(_1$$3, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_6$$3, "strtr", NULL, 26, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_7$$3);
ZVAL_STRING(_7$$3, "Alnum", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _1$$3, "__construct", NULL, 466, _6$$3, field, _7$$3, code);
zephir_check_temp_parameter(_7$$3);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _1$$3);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
/**
* Phalcon\Http\Cookie constructor
*
* @param string name
* @param mixed value
* @param int expire
* @param string path
* @param boolean secure
* @param string domain
* @param boolean httpOnly
*/
PHP_METHOD(Phalcon_Http_Cookie, __construct) {
int ZEPHIR_LAST_CALL_STATUS;
zval *name_param = NULL, *value = NULL, *expire = NULL, *path = NULL, *secure = NULL, *domain = NULL, *httpOnly = NULL;
zval *name = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 6, &name_param, &value, &expire, &path, &secure, &domain, &httpOnly);
if (unlikely(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 (likely(Z_TYPE_P(name_param) == IS_STRING)) {
zephir_get_strval(name, name_param);
} else {
ZEPHIR_INIT_VAR(name);
ZVAL_EMPTY_STRING(name);
}
if (!value) {
value = ZEPHIR_GLOBAL(global_null);
}
if (!expire) {
ZEPHIR_INIT_VAR(expire);
ZVAL_LONG(expire, 0);
}
if (!path) {
ZEPHIR_INIT_VAR(path);
ZVAL_STRING(path, "/", 1);
}
if (!secure) {
secure = ZEPHIR_GLOBAL(global_null);
}
if (!domain) {
domain = ZEPHIR_GLOBAL(global_null);
}
if (!httpOnly) {
httpOnly = ZEPHIR_GLOBAL(global_null);
}
zephir_update_property_this(this_ptr, SL("_name"), name TSRMLS_CC);
if (Z_TYPE_P(value) != IS_NULL) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "setvalue", NULL, 0, value);
zephir_check_call_status();
}
zephir_update_property_this(this_ptr, SL("_expire"), expire TSRMLS_CC);
if (Z_TYPE_P(path) != IS_NULL) {
zephir_update_property_this(this_ptr, SL("_path"), path TSRMLS_CC);
}
if (Z_TYPE_P(secure) != IS_NULL) {
zephir_update_property_this(this_ptr, SL("_secure"), secure TSRMLS_CC);
}
if (Z_TYPE_P(domain) != IS_NULL) {
zephir_update_property_this(this_ptr, SL("_domain"), domain TSRMLS_CC);
}
if (Z_TYPE_P(httpOnly) != IS_NULL) {
zephir_update_property_this(this_ptr, SL("_httpOnly"), httpOnly TSRMLS_CC);
}
ZEPHIR_MM_RESTORE();
}
/**
* Listens for notifications from the models manager
*/
PHP_METHOD(Phalcon_Mvc_Collection_Behavior_Timestampable, notify) {
HashTable *_2$$12;
HashPosition _1$$12;
zephir_fcall_cache_entry *_4 = NULL;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *type_param = NULL, *model, *options = NULL, *timestamp = NULL, *singleField = NULL, *field = NULL, *generator = NULL, *format = NULL, *_0 = NULL, **_3$$12;
zval *type = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &type_param, &model);
if (UNEXPECTED(Z_TYPE_P(type_param) != IS_STRING && Z_TYPE_P(type_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'type' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(type_param) == IS_STRING)) {
zephir_get_strval(type, type_param);
} else {
ZEPHIR_INIT_VAR(type);
ZVAL_EMPTY_STRING(type);
}
ZEPHIR_CALL_METHOD(&_0, this_ptr, "musttakeaction", NULL, 0, type);
zephir_check_call_status();
if (!ZEPHIR_IS_TRUE_IDENTICAL(_0)) {
RETURN_MM_NULL();
}
ZEPHIR_CALL_METHOD(&options, this_ptr, "getoptions", NULL, 0, type);
zephir_check_call_status();
if (Z_TYPE_P(options) == IS_ARRAY) {
ZEPHIR_OBS_VAR(field);
if (!(zephir_array_isset_string_fetch(&field, options, SS("field"), 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_collection_exception_ce, "The option 'field' is required", "phalcon/mvc/collection/behavior/timestampable.zep", 56);
return;
}
ZEPHIR_INIT_VAR(timestamp);
ZVAL_NULL(timestamp);
ZEPHIR_OBS_VAR(format);
if (zephir_array_isset_string_fetch(&format, options, SS("format"), 0 TSRMLS_CC)) {
ZEPHIR_CALL_FUNCTION(×tamp, "date", NULL, 311, format);
zephir_check_call_status();
} else {
ZEPHIR_OBS_VAR(generator);
if (zephir_array_isset_string_fetch(&generator, options, SS("generator"), 0 TSRMLS_CC)) {
if (Z_TYPE_P(generator) == IS_OBJECT) {
if (zephir_instance_of_ev(generator, zend_ce_closure TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(timestamp);
ZEPHIR_CALL_USER_FUNC(timestamp, generator);
zephir_check_call_status();
}
}
}
}
if (Z_TYPE_P(timestamp) == IS_NULL) {
ZEPHIR_INIT_NVAR(timestamp);
zephir_time(timestamp);
}
if (Z_TYPE_P(field) == IS_ARRAY) {
zephir_is_iterable(field, &_2$$12, &_1$$12, 0, 0, "phalcon/mvc/collection/behavior/timestampable.zep", 94);
for (
; zend_hash_get_current_data_ex(_2$$12, (void**) &_3$$12, &_1$$12) == SUCCESS
; zend_hash_move_forward_ex(_2$$12, &_1$$12)
) {
ZEPHIR_GET_HVALUE(singleField, _3$$12);
ZEPHIR_CALL_METHOD(NULL, model, "writeattribute", &_4, 0, singleField, timestamp);
zephir_check_call_status();
}
} else {
ZEPHIR_CALL_METHOD(NULL, model, "writeattribute", NULL, 0, field, timestamp);
zephir_check_call_status();
}
}
ZEPHIR_MM_RESTORE();
}
/**
* Tries to render the view with every engine registered in the component
*
* @param string path
* @param array params
*/
PHP_METHOD(Phalcon_Mvc_View_Simple, _internalRender) {
zephir_fcall_cache_entry *_11 = NULL, *_13 = NULL;
HashTable *_4;
HashPosition _3;
int ZEPHIR_LAST_CALL_STATUS;
zend_bool notExists, mustClean, _7, _9;
zval *path_param = NULL, *params, *eventsManager, *engines = NULL, *extension = NULL, *engine = NULL, *viewEnginePath = NULL, *viewsDirPath, *_0 = NULL, *_1 = NULL, *_2, **_5, *_6 = NULL, _8 = zval_used_for_init, *_10 = NULL, *_12 = NULL;
zval *path = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &path_param, ¶ms);
if (unlikely(Z_TYPE_P(path_param) != IS_STRING && Z_TYPE_P(path_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'path' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(path_param) == IS_STRING)) {
zephir_get_strval(path, path_param);
} else {
ZEPHIR_INIT_VAR(path);
ZVAL_EMPTY_STRING(path);
}
ZEPHIR_OBS_VAR(eventsManager);
zephir_read_property_this(&eventsManager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
zephir_update_property_this(this_ptr, SL("_activeRenderPath"), path TSRMLS_CC);
}
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "view:beforeRender", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_0, eventsManager, "fire", NULL, 0, _1, this_ptr);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_0)) {
RETURN_MM_NULL();
}
}
notExists = 1;
mustClean = 1;
_2 = zephir_fetch_nproperty_this(this_ptr, SL("_viewsDir"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(viewsDirPath);
ZEPHIR_CONCAT_VV(viewsDirPath, _2, path);
ZEPHIR_CALL_METHOD(&engines, this_ptr, "_loadtemplateengines", NULL, 0);
zephir_check_call_status();
zephir_is_iterable(engines, &_4, &_3, 0, 0, "phalcon/mvc/view/simple.zep", 261);
for (
; zephir_hash_get_current_data_ex(_4, (void**) &_5, &_3) == SUCCESS
; zephir_hash_move_forward_ex(_4, &_3)
) {
ZEPHIR_GET_HMKEY(extension, _4, _3);
ZEPHIR_GET_HVALUE(engine, _5);
ZEPHIR_INIT_LNVAR(_6);
ZEPHIR_CONCAT_VV(_6, viewsDirPath, extension);
if ((zephir_file_exists(_6 TSRMLS_CC) == SUCCESS)) {
ZEPHIR_INIT_NVAR(viewEnginePath);
ZEPHIR_CONCAT_VV(viewEnginePath, viewsDirPath, extension);
} else {
_7 = zephir_is_true(extension);
if (_7) {
ZEPHIR_SINIT_NVAR(_8);
ZVAL_LONG(&_8, -zephir_fast_strlen_ev(extension));
ZEPHIR_INIT_NVAR(_1);
zephir_substr(_1, viewsDirPath, zephir_get_intval(&_8), 0, ZEPHIR_SUBSTR_NO_LENGTH);
_7 = ZEPHIR_IS_EQUAL(_1, extension);
}
_9 = _7;
if (_9) {
_9 = (zephir_file_exists(viewsDirPath TSRMLS_CC) == SUCCESS);
}
if (_9) {
ZEPHIR_CPY_WRT(viewEnginePath, viewsDirPath);
} else {
ZEPHIR_INIT_NVAR(viewEnginePath);
ZVAL_STRING(viewEnginePath, "", 1);
}
}
if (zephir_is_true(viewEnginePath)) {
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_10);
ZVAL_STRING(_10, "view:beforeRenderView", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_0, eventsManager, "fire", &_11, 0, _10, this_ptr, viewEnginePath);
zephir_check_temp_parameter(_10);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_0)) {
continue;
}
}
ZEPHIR_INIT_NVAR(_10);
if (mustClean) {
ZVAL_BOOL(_10, 1);
} else {
ZVAL_BOOL(_10, 0);
}
ZEPHIR_CALL_METHOD(NULL, engine, "render", NULL, 0, viewEnginePath, params, _10);
zephir_check_call_status();
notExists = 0;
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_12);
ZVAL_STRING(_12, "view:afterRenderView", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", &_13, 0, _12, this_ptr);
zephir_check_temp_parameter(_12);
zephir_check_call_status();
}
break;
}
}
if (notExists == 1) {
ZEPHIR_INIT_NVAR(_1);
object_init_ex(_1, phalcon_mvc_view_exception_ce);
ZEPHIR_INIT_LNVAR(_6);
ZEPHIR_CONCAT_SVS(_6, "View '", viewsDirPath, "' was not found in the views directory");
ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, 9, _6);
zephir_check_call_status();
zephir_throw_exception_debug(_1, "phalcon/mvc/view/simple.zep", 262 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "view:afterRender", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, 0, _1, this_ptr);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
}
ZEPHIR_MM_RESTORE();
}
/**
* Lists table indexes
*
* <code>
* print_r($connection->describeIndexes('robots_parts'));
* </code>
*
* @param string table
* @param string schema
* @return \Phalcon\Db\IndexInterface[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Mysql, describeIndexes) {
HashTable *_5, *_15;
HashPosition _4, _14;
zephir_fcall_cache_entry *_20 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *table_param = NULL, *schema = NULL, *indexes = NULL, *index = NULL, *keyName = NULL, *indexObjects = NULL, *columns = NULL, *name = NULL, *_0 = NULL, *_1, *_2 = NULL, *_3, **_6, **_16, *_7$$4 = NULL, *_8$$3, *_10$$3, *_11$$3, *_9$$6, *_12$$7 = NULL, *_13$$8 = NULL, *_17$$10 = NULL, *_18$$10, *_19$$10;
zval *table = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &table_param, &schema);
if (unlikely(Z_TYPE_P(table_param) != IS_STRING && Z_TYPE_P(table_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'table' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(table_param) == IS_STRING)) {
zephir_get_strval(table, table_param);
} else {
ZEPHIR_INIT_VAR(table);
ZVAL_EMPTY_STRING(table);
}
if (!schema) {
schema = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_INIT_VAR(indexes);
array_init(indexes);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_dialect"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&_2, _1, "describeindexes", NULL, 0, table, schema);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_3);
ZVAL_LONG(_3, 2);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "fetchall", NULL, 0, _2, _3);
zephir_check_call_status();
zephir_is_iterable(_0, &_5, &_4, 0, 0, "phalcon/db/adapter/pdo/mysql.zep", 389);
for (
; zephir_hash_get_current_data_ex(_5, (void**) &_6, &_4) == SUCCESS
; zephir_hash_move_forward_ex(_5, &_4)
) {
ZEPHIR_GET_HVALUE(index, _6);
zephir_array_fetch_string(&keyName, index, SL("Key_name"), PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/mysql.zep", 365 TSRMLS_CC);
if (!(zephir_array_isset(indexes, keyName))) {
ZEPHIR_INIT_NVAR(_7$$4);
array_init(_7$$4);
zephir_array_update_zval(&indexes, keyName, &_7$$4, PH_COPY | PH_SEPARATE);
}
zephir_array_fetch(&_8$$3, indexes, keyName, PH_READONLY, "phalcon/db/adapter/pdo/mysql.zep", 371 TSRMLS_CC);
if (!(zephir_array_isset_string(_8$$3, SS("columns")))) {
ZEPHIR_INIT_NVAR(columns);
array_init(columns);
} else {
zephir_array_fetch(&_9$$6, indexes, keyName, PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/mysql.zep", 374 TSRMLS_CC);
ZEPHIR_OBS_NVAR(columns);
zephir_array_fetch_string(&columns, _9$$6, SL("columns"), PH_NOISY, "phalcon/db/adapter/pdo/mysql.zep", 374 TSRMLS_CC);
}
zephir_array_fetch_string(&_10$$3, index, SL("Column_name"), PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/mysql.zep", 377 TSRMLS_CC);
zephir_array_append(&columns, _10$$3, PH_SEPARATE, "phalcon/db/adapter/pdo/mysql.zep", 377);
zephir_array_update_multi(&indexes, &columns TSRMLS_CC, SL("zs"), 3, keyName, SL("columns"));
zephir_array_fetch_string(&_11$$3, index, SL("Non_unique"), PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/mysql.zep", 382 TSRMLS_CC);
if (ZEPHIR_IS_STRING(keyName, "PRIMARY")) {
ZEPHIR_INIT_NVAR(_12$$7);
ZVAL_STRING(_12$$7, "PRIMARY", 1);
zephir_array_update_multi(&indexes, &_12$$7 TSRMLS_CC, SL("zs"), 3, keyName, SL("type"));
} else if (ZEPHIR_IS_LONG(_11$$3, 0)) {
ZEPHIR_INIT_NVAR(_13$$8);
ZVAL_STRING(_13$$8, "UNIQUE", 1);
zephir_array_update_multi(&indexes, &_13$$8 TSRMLS_CC, SL("zs"), 3, keyName, SL("type"));
} else {
zephir_array_update_multi(&indexes, &ZEPHIR_GLOBAL(global_null) TSRMLS_CC, SL("zs"), 3, keyName, SL("type"));
}
}
ZEPHIR_INIT_VAR(indexObjects);
array_init(indexObjects);
zephir_is_iterable(indexes, &_15, &_14, 0, 0, "phalcon/db/adapter/pdo/mysql.zep", 394);
for (
; zephir_hash_get_current_data_ex(_15, (void**) &_16, &_14) == SUCCESS
; zephir_hash_move_forward_ex(_15, &_14)
) {
ZEPHIR_GET_HMKEY(name, _15, _14);
ZEPHIR_GET_HVALUE(index, _16);
ZEPHIR_INIT_NVAR(_17$$10);
object_init_ex(_17$$10, phalcon_db_index_ce);
zephir_array_fetch_string(&_18$$10, index, SL("columns"), PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/mysql.zep", 391 TSRMLS_CC);
zephir_array_fetch_string(&_19$$10, index, SL("type"), PH_NOISY | PH_READONLY, "phalcon/db/adapter/pdo/mysql.zep", 391 TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, _17$$10, "__construct", &_20, 15, name, _18$$10, _19$$10);
zephir_check_call_status();
zephir_array_update_zval(&indexObjects, name, &_17$$10, PH_COPY | PH_SEPARATE);
}
RETURN_CCTOR(indexObjects);
}
/**
* Reads and decodes a JSON-encoded file into an object or array
*
* @param string $file A readable JSON file.
* @param boolean $assoc [Optional] Whether to decode to an associative array. Default false.
* @param int $depth [Optional] Depth to decode to. Default 512
* @param int $flags [Optional] Bitwise flags for use in json_decode(). Default is 0
* @return object|array|null JSON data decoded to object(s) or array(s).
*/
PHP_METHOD(Xpl_Json, decodeFile) {
int depth, flags, ZEPHIR_LAST_CALL_STATUS;
zend_bool assoc;
zval *file_param = NULL, *assoc_param = NULL, *depth_param = NULL, *flags_param = NULL, *json = NULL, *_2, *_3, *_4, *_0$$3;
zval *file = NULL, *_1$$3;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 3, &file_param, &assoc_param, &depth_param, &flags_param);
if (unlikely(Z_TYPE_P(file_param) != IS_STRING && Z_TYPE_P(file_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'file' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(file_param) == IS_STRING)) {
zephir_get_strval(file, file_param);
} else {
ZEPHIR_INIT_VAR(file);
ZVAL_EMPTY_STRING(file);
}
if (!assoc_param) {
assoc = 0;
} else {
assoc = zephir_get_boolval(assoc_param);
}
if (!depth_param) {
depth = 512;
} else {
depth = zephir_get_intval(depth_param);
}
if (!flags_param) {
flags = 0;
} else {
flags = zephir_get_intval(flags_param);
}
if (!((zephir_file_exists(file TSRMLS_CC) == SUCCESS))) {
ZEPHIR_INIT_VAR(_0$$3);
object_init_ex(_0$$3, spl_ce_RuntimeException);
ZEPHIR_INIT_VAR(_1$$3);
ZEPHIR_CONCAT_SV(_1$$3, "Unreadable file: ", file);
ZEPHIR_CALL_METHOD(NULL, _0$$3, "__construct", NULL, 111, _1$$3);
zephir_check_call_status();
zephir_throw_exception_debug(_0$$3, "xpl/json.zep", 62 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_INIT_VAR(json);
zephir_file_get_contents(json, file TSRMLS_CC);
ZEPHIR_INIT_VAR(_2);
if (assoc) {
ZVAL_BOOL(_2, 1);
} else {
ZVAL_BOOL(_2, 0);
}
ZEPHIR_INIT_VAR(_3);
ZVAL_LONG(_3, depth);
ZEPHIR_INIT_VAR(_4);
ZVAL_LONG(_4, flags);
ZEPHIR_RETURN_CALL_SELF("decode", NULL, 0, json, _2, _3, _4);
zephir_check_call_status();
RETURN_MM();
}
