/** * 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(); }