/** * Returns whether the given variable is a valid JSON string. * * @param string * @return boolean */ PHP_METHOD(Xpl_Json, validate) { zend_bool _0; int ZEPHIR_LAST_CALL_STATUS; zval *str_param = NULL, *_1, *_2 = NULL; zval *str = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &str_param); zephir_get_strval(str, str_param); if (ZEPHIR_IS_EMPTY(str)) { RETURN_MM_BOOL(0); } _0 = ZEPHIR_IS_STRING_IDENTICAL(str, "{}"); if (!(_0)) { _0 = ZEPHIR_IS_STRING_IDENTICAL(str, "[]"); } if (_0) { RETURN_MM_BOOL(1); } ZEPHIR_INIT_VAR(_1); zephir_json_decode(_1, &(_1), str, 0 TSRMLS_CC); ZEPHIR_CALL_FUNCTION(&_2, "json_last_error", NULL, 112); zephir_check_call_status(); RETURN_MM_BOOL(ZEPHIR_IS_LONG_IDENTICAL(_2, 0)); }
/** * Returns all the filters or a specific one * * @param string field * @return mixed */ PHP_METHOD(Phalcon_Validation, getFilters) { zend_bool _0; zval *field_param = NULL, *filters = NULL, *fieldFilters = NULL; zval *field = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &field_param); if (!field_param) { ZEPHIR_INIT_VAR(field); ZVAL_EMPTY_STRING(field); } else { zephir_get_strval(field, field_param); } filters = zephir_fetch_nproperty_this(this_ptr, SL("_filters"), PH_NOISY_CC); _0 = ZEPHIR_IS_STRING_IDENTICAL(field, ""); if (!(_0)) { _0 = ZEPHIR_IS_STRING_IDENTICAL(field, ""); } if (_0) { RETURN_CTOR(filters); } if (!(zephir_array_isset_fetch(&fieldFilters, filters, field, 1 TSRMLS_CC))) { RETURN_MM_NULL(); } RETURN_CTOR(fieldFilters); }
PHP_METHOD(Cake_Core_Configure, _getEngine) { int ZEPHIR_LAST_CALL_STATUS; zval *config_param = NULL, *_0, *_1, *_2, *_3; zval *config = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &config_param); zephir_get_strval(config, config_param); _0 = zephir_fetch_static_property_ce(cake_core_configure_ce, SL("_engines") TSRMLS_CC); if (!(zephir_array_isset(_0, config))) { if (!ZEPHIR_IS_STRING_IDENTICAL(config, "default")) { RETURN_MM_BOOL(0); } ZEPHIR_INIT_VAR(_1); object_init_ex(_1, cake_core_configure_engine_phpconfig_ce); ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, 7); zephir_check_call_status(); ZEPHIR_CALL_SELF(NULL, "config", NULL, 0, config, _1); zephir_check_call_status(); } _2 = zephir_fetch_static_property_ce(cake_core_configure_ce, SL("_engines") TSRMLS_CC); zephir_array_fetch(&_3, _2, config, PH_NOISY | PH_READONLY, "cake/Core/Configure.zep", 93 TSRMLS_CC); RETURN_CTOR(_3); }
/** * Returns the behavior options related to an event * * @param string eventName * @return array */ PHP_METHOD(Phalcon_Mvc_Model_Behavior, getOptions) { zval *eventName_param = NULL, *options = NULL, *eventOptions = NULL; zval *eventName = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &eventName_param); if (!eventName_param) { ZEPHIR_INIT_VAR(eventName); ZVAL_EMPTY_STRING(eventName); } else { if (unlikely(Z_TYPE_P(eventName_param) != IS_STRING && Z_TYPE_P(eventName_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'eventName' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(eventName_param) == IS_STRING)) { zephir_get_strval(eventName, eventName_param); } else { ZEPHIR_INIT_VAR(eventName); ZVAL_EMPTY_STRING(eventName); } } options = zephir_fetch_nproperty_this(this_ptr, SL("_options"), PH_NOISY_CC); if (!ZEPHIR_IS_STRING_IDENTICAL(eventName, "")) { if (zephir_array_isset_fetch(&eventOptions, options, eventName, 1 TSRMLS_CC)) { RETURN_CTOR(eventOptions); } RETURN_MM_NULL(); } RETURN_CTOR(options); }
PHP_METHOD(Yaf_Request_Abstract, getQuery) { zval *name_param = NULL, *tmpDefault = NULL, *get = NULL, *_GET, *_0 = NULL; zval *name = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 2, &name_param, &tmpDefault); if (!name_param) { ZEPHIR_INIT_VAR(name); ZVAL_EMPTY_STRING(name); } else { zephir_get_strval(name, name_param); } if (!tmpDefault) { tmpDefault = ZEPHIR_GLOBAL(global_null); } zephir_get_global(&_GET, SS("_GET") TSRMLS_CC); ZEPHIR_CPY_WRT(get, _GET); if (ZEPHIR_IS_STRING_IDENTICAL(name, "")) { RETVAL_ZVAL(_GET, 1, 0); RETURN_MM(); } ZEPHIR_INIT_VAR(_0); if (zephir_array_isset(get, name)) { zephir_array_fetch(&_0, get, name, PH_NOISY, "yaf/request_abstract.zep", 115 TSRMLS_CC); } else { ZEPHIR_CPY_WRT(_0, tmpDefault); } RETURN_CCTOR(_0); }
/** * {@inheritdoc} */ PHP_METHOD(Phalcon_Session_Adapter_Libmemcached, destroy) { int ZEPHIR_LAST_CALL_STATUS; zval *sessionId_param = NULL, *id = NULL, *_0; zval *sessionId = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &sessionId_param); if (!sessionId_param) { ZEPHIR_INIT_VAR(sessionId); ZVAL_EMPTY_STRING(sessionId); } else { zephir_get_strval(sessionId, sessionId_param); } if (ZEPHIR_IS_STRING_IDENTICAL(sessionId, "")) { ZEPHIR_CALL_METHOD(&id, this_ptr, "getid", NULL, 0); zephir_check_call_status(); } else { ZEPHIR_CPY_WRT(id, sessionId); } _0 = zephir_fetch_nproperty_this(this_ptr, SL("_libmemcached"), PH_NOISY_CC); ZEPHIR_RETURN_CALL_METHOD(_0, "delete", NULL, 0, id); zephir_check_call_status(); RETURN_MM(); }
/** * Load translates from file * * @param string file * @param int length * @param string delimiter * @param string enclosure */ PHP_METHOD(Phalcon_Translate_Adapter_Csv, _load) { zend_bool _6; zephir_fcall_cache_entry *_3 = NULL; int ZEPHIR_LAST_CALL_STATUS; zval *file, *length, *delimiter, *enclosure, *data = NULL, *fileHandler = NULL, _0 = zval_used_for_init, *_1 = NULL, *_2, *_4, _5 = zval_used_for_init, *_7, *_8 = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 4, 0, &file, &length, &delimiter, &enclosure); ZEPHIR_SINIT_VAR(_0); ZVAL_STRING(&_0, "rb", 0); ZEPHIR_CALL_FUNCTION(&fileHandler, "fopen", NULL, 292, file, &_0); zephir_check_call_status(); if (Z_TYPE_P(fileHandler) != IS_RESOURCE) { ZEPHIR_INIT_VAR(_1); object_init_ex(_1, phalcon_translate_exception_ce); ZEPHIR_INIT_VAR(_2); ZEPHIR_CONCAT_SVS(_2, "Error opening translation file '", file, "'"); ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, 9, _2); zephir_check_call_status(); zephir_throw_exception_debug(_1, "phalcon/translate/adapter/csv.zep", 64 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } while (1) { ZEPHIR_CALL_FUNCTION(&data, "fgetcsv", &_3, 428, fileHandler, length, delimiter, enclosure); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(data)) { break; } zephir_array_fetch_long(&_4, data, 0, PH_NOISY | PH_READONLY, "phalcon/translate/adapter/csv.zep", 74 TSRMLS_CC); ZEPHIR_SINIT_NVAR(_0); ZVAL_LONG(&_0, 0); ZEPHIR_SINIT_NVAR(_5); ZVAL_LONG(&_5, 1); ZEPHIR_INIT_NVAR(_1); zephir_substr(_1, _4, 0 , 1 , 0); _6 = ZEPHIR_IS_STRING_IDENTICAL(_1, "#"); if (!(_6)) { _6 = !(zephir_array_isset_long(data, 1)); } if (_6) { continue; } zephir_array_fetch_long(&_7, data, 1, PH_NOISY | PH_READONLY, "phalcon/translate/adapter/csv.zep", 78 TSRMLS_CC); ZEPHIR_OBS_NVAR(_8); zephir_array_fetch_long(&_8, data, 0, PH_NOISY, "phalcon/translate/adapter/csv.zep", 78 TSRMLS_CC); zephir_update_property_array(this_ptr, SL("_translate"), _8, _7 TSRMLS_CC); } zephir_fclose(fileHandler TSRMLS_CC); ZEPHIR_MM_RESTORE(); }
/** * @link https://github.com/phalcon/zephir/issues/411 */ PHP_METHOD(Test_Compare, testVarWithStringEquals) { zval *str_param = NULL; zval str; zval *this_ptr = getThis(); ZVAL_UNDEF(&str); ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &str_param); if (UNEXPECTED(Z_TYPE_P(str_param) != IS_STRING && Z_TYPE_P(str_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'str' must be of the type string") TSRMLS_CC); RETURN_MM_NULL(); } if (EXPECTED(Z_TYPE_P(str_param) == IS_STRING)) { zephir_get_strval(&str, str_param); } else { ZEPHIR_INIT_VAR(&str); ZVAL_EMPTY_STRING(&str); } if (ZEPHIR_IS_STRING_IDENTICAL(&str, "wrong testing")) { ZEPHIR_INIT_NVAR(&str); ZVAL_STRING(&str, "NOK"); } else { if (ZEPHIR_IS_STRING_IDENTICAL(&str, "another testing")) { ZEPHIR_INIT_NVAR(&str); ZVAL_STRING(&str, "NOK"); } else { if (ZEPHIR_IS_STRING_IDENTICAL(&str, "testing")) { ZEPHIR_INIT_NVAR(&str); ZVAL_STRING(&str, "OK"); } else { ZEPHIR_INIT_NVAR(&str); ZVAL_STRING(&str, "NOK"); } } } RETURN_CTOR(&str); }
/** * {@inheritdoc} */ PHP_METHOD(Phalcon_Session_Adapter_Libmemcached, destroy) { HashTable *_2; HashPosition _1; int ZEPHIR_LAST_CALL_STATUS; zval *sessionId_param = NULL, *_SESSION, *id = NULL, *key = NULL, *_0 = NULL, **_3, *_4 = NULL, *_5, *_6 = NULL, *_7; zval *sessionId = NULL; ZEPHIR_MM_GROW(); zephir_get_global(&_SESSION, SS("_SESSION") TSRMLS_CC); zephir_fetch_params(1, 0, 1, &sessionId_param); if (!sessionId_param) { ZEPHIR_INIT_VAR(sessionId); ZVAL_EMPTY_STRING(sessionId); } else { zephir_get_strval(sessionId, sessionId_param); } if (ZEPHIR_IS_STRING_IDENTICAL(sessionId, "")) { ZEPHIR_CALL_METHOD(&id, this_ptr, "getid", NULL, 0); zephir_check_call_status(); } else { ZEPHIR_CPY_WRT(id, sessionId); } ZEPHIR_INIT_VAR(_0); zephir_is_iterable(_SESSION, &_2, &_1, 1, 0, "phalcon/session/adapter/libmemcached.zep", 168); for ( ; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS ; zephir_hash_move_forward_ex(_2, &_1) ) { ZEPHIR_GET_HMKEY(key, _2, _1); ZEPHIR_GET_HVALUE(_0, _3); zephir_array_unset(&_SESSION, key, PH_SEPARATE); } zend_hash_destroy(_2); FREE_HASHTABLE(_2); ZEPHIR_INIT_VAR(_4); _5 = zephir_fetch_nproperty_this(this_ptr, SL("_libmemcached"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(&_6, _5, "exists", NULL, 0, id); zephir_check_call_status(); if (zephir_is_true(_6)) { _7 = zephir_fetch_nproperty_this(this_ptr, SL("_libmemcached"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(&_4, _7, "delete", NULL, 0, id); zephir_check_call_status(); } else { ZVAL_BOOL(_4, 1); } RETURN_CCTOR(_4); }
/** * @param array data * @return \Phal\Entity */ PHP_METHOD(Phal_Format_Reader_Hal_JsonReader, doTransformEmbedded) { zephir_fcall_cache_entry *_7 = NULL; zephir_nts_static zephir_fcall_cache_entry *_6 = NULL; HashTable *_1; HashPosition _0; int ZEPHIR_LAST_CALL_STATUS; zval *data, *resource, *key = NULL, *value = NULL, **_2, _3 = zval_used_for_init, _4 = zval_used_for_init, *_5 = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &data); if (Z_TYPE_P(data) != IS_ARRAY) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "data must be array", "phal/format/reader/hal/jsonreader.zep", 227); return; } ZEPHIR_INIT_VAR(resource); object_init_ex(resource, phal_entity_ce); ZEPHIR_CALL_METHOD(NULL, resource, "__construct", NULL); zephir_check_call_status(); zephir_is_iterable(data, &_1, &_0, 0, 0); for ( ; zephir_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS ; zephir_hash_move_forward_ex(_1, &_0) ) { ZEPHIR_GET_HMKEY(key, _1, _0); ZEPHIR_GET_HVALUE(value, _2); ZEPHIR_SINIT_NVAR(_3); ZVAL_LONG(&_3, 0); ZEPHIR_SINIT_NVAR(_4); ZVAL_LONG(&_4, 1); ZEPHIR_CALL_FUNCTION(&_5, "substr", &_6, key, &_3, &_4); zephir_check_call_status(); if (!ZEPHIR_IS_STRING_IDENTICAL(_5, "_")) { ZEPHIR_CALL_METHOD(NULL, resource, "adddata", &_7, key, value); zephir_check_call_status(); } } ZEPHIR_CALL_METHOD(NULL, this_ptr, "transformmetadata", NULL, resource, data); zephir_check_call_status(); RETURN_CCTOR(resource); }
/** * {@inheritdoc} */ PHP_METHOD(Phalcon_Session_Adapter_Memcache, destroy) { zend_bool _0; zend_long ZEPHIR_LAST_CALL_STATUS; zval *sessionId_param = NULL, *id = NULL, *_1, *_2 = NULL, *_3$$5, *_4$$5 = NULL; zval *sessionId = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &sessionId_param); if (!sessionId_param) { ZEPHIR_INIT_VAR(sessionId); ZVAL_EMPTY_STRING(sessionId); } else { zephir_get_strval(sessionId, sessionId_param); } if (ZEPHIR_IS_STRING_IDENTICAL(sessionId, "")) { ZEPHIR_CALL_METHOD(&id, this_ptr, "getid", NULL, 0); zephir_check_call_status(); } else { ZEPHIR_CPY_WRT(id, sessionId); } ZEPHIR_CALL_METHOD(NULL, this_ptr, "removesessiondata", NULL, 0); zephir_check_call_status(); _0 = !(ZEPHIR_IS_EMPTY(id)); if (_0) { _1 = zephir_fetch_nproperty_this(this_ptr, SL("_memcache"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(&_2, _1, "exists", NULL, 0, id); zephir_check_call_status(); _0 = zephir_is_true(_2); } if (_0) { _3$$5 = zephir_fetch_nproperty_this(this_ptr, SL("_memcache"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(&_4$$5, _3$$5, "delete", NULL, 0, id); zephir_check_call_status(); RETURN_MM_BOOL(zephir_get_boolval(_4$$5)); } RETURN_MM_BOOL(1); }
/** * {@inheritdoc} */ PHP_METHOD(Phalcon_Session_Adapter_Redis, destroy) { zend_long ZEPHIR_LAST_CALL_STATUS; zval *sessionId_param = NULL, *id = NULL, *_0 = NULL, *_1, *_2 = NULL, *_3; zval *sessionId = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &sessionId_param); if (!sessionId_param) { ZEPHIR_INIT_VAR(sessionId); ZVAL_EMPTY_STRING(sessionId); } else { zephir_get_strval(sessionId, sessionId_param); } if (ZEPHIR_IS_STRING_IDENTICAL(sessionId, "")) { ZEPHIR_CALL_METHOD(&id, this_ptr, "getid", NULL, 0); zephir_check_call_status(); } else { ZEPHIR_CPY_WRT(id, sessionId); } ZEPHIR_CALL_METHOD(NULL, this_ptr, "removesessiondata", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(_0); _1 = zephir_fetch_nproperty_this(this_ptr, SL("_redis"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(&_2, _1, "exists", NULL, 0, id); zephir_check_call_status(); if (zephir_is_true(_2)) { _3 = zephir_fetch_nproperty_this(this_ptr, SL("_redis"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(&_0, _3, "delete", NULL, 0, id); zephir_check_call_status(); } else { ZVAL_BOOL(_0, 1); } RETURN_CCTOR(_0); }
/** * Removes all events from the EventsManager * * @param string type */ PHP_METHOD(Phalcon_Events_Manager, detachAll) { zval *type_param = NULL, *_0, *_1; zval *type = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &type_param); if (!type_param) { ZEPHIR_INIT_VAR(type); ZVAL_EMPTY_STRING(type); } else { if (unlikely(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 (likely(Z_TYPE_P(type_param) == IS_STRING)) { zephir_get_strval(type, type_param); } else { ZEPHIR_INIT_VAR(type); ZVAL_EMPTY_STRING(type); } } if (ZEPHIR_IS_STRING_IDENTICAL(type, "")) { zephir_update_property_this(this_ptr, SL("_events"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC); } else { _0 = zephir_fetch_nproperty_this(this_ptr, SL("_events"), PH_NOISY_CC); if (zephir_array_isset(_0, type)) { _1 = zephir_fetch_nproperty_this(this_ptr, SL("_events"), PH_NOISY_CC); zephir_array_unset(&_1, type, PH_SEPARATE); } } ZEPHIR_MM_RESTORE(); }
/** * Creates an ItemPool for the given namespace. * * @param string namespaceName * * @return \Xpl\Cache\ItemPool */ PHP_METHOD(Xpl_Cache_Cache, createPool) { int ZEPHIR_LAST_CALL_STATUS; zval *name_param = NULL, *config = NULL, *driver = NULL, *driverClass = NULL, *prefix = NULL, *cachePrefix = NULL, *defaultTtl = NULL, *_0, *_5, *_1$$5, _2$$5, *_3$$5; zval *name = NULL, *_4$$7; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &name_param); 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); } ZEPHIR_CALL_METHOD(&config, this_ptr, "getconfig", NULL, 0, name); zephir_check_call_status(); ZEPHIR_OBS_VAR(driverClass); if (zephir_array_isset_string_fetch(&driverClass, config, SS("driver"), 0 TSRMLS_CC)) { ZEPHIR_INIT_VAR(driver); ZEPHIR_LAST_CALL_STATUS = zephir_create_instance(driver, driverClass TSRMLS_CC); zephir_check_call_status(); } else { ZEPHIR_CALL_METHOD(&driver, this_ptr, "getdriver", NULL, 0); zephir_check_call_status(); } _0 = zephir_fetch_nproperty_this(this_ptr, SL("prefix"), PH_NOISY_CC); ZEPHIR_CPY_WRT(prefix, _0); ZEPHIR_OBS_VAR(cachePrefix); if (zephir_array_isset_string_fetch(&cachePrefix, config, SS("prefix"), 0 TSRMLS_CC)) { ZEPHIR_INIT_VAR(_1$$5); ZEPHIR_SINIT_VAR(_2$$5); ZVAL_STRING(&_2$$5, ".", 0); zephir_fast_trim(_1$$5, cachePrefix, &_2$$5, ZEPHIR_TRIM_BOTH TSRMLS_CC); ZEPHIR_INIT_VAR(_3$$5); ZEPHIR_CONCAT_VS(_3$$5, _1$$5, "."); zephir_concat_self(&prefix, _3$$5 TSRMLS_CC); } else { if (!ZEPHIR_IS_STRING_IDENTICAL(name, "default")) { ZEPHIR_INIT_VAR(_4$$7); ZEPHIR_CONCAT_VS(_4$$7, name, "."); zephir_concat_self(&prefix, _4$$7 TSRMLS_CC); } } ZEPHIR_OBS_VAR(defaultTtl); if (!(zephir_array_isset_string_fetch(&defaultTtl, config, SS("default_ttl"), 0 TSRMLS_CC))) { ZEPHIR_INIT_NVAR(defaultTtl); ZVAL_LONG(defaultTtl, 0); } object_init_ex(return_value, xpl_cache_itempool_ce); ZEPHIR_INIT_VAR(_5); ZVAL_LONG(_5, zephir_get_intval(defaultTtl)); ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 26, driver, prefix, _5); zephir_check_call_status(); RETURN_MM(); }
/** * Phalcon\Translate\Adapter\Csv constructor */ PHP_METHOD(Phalcon_Translate_Adapter_Csv, __construct) { zend_bool _12; zephir_fcall_cache_entry *_9 = NULL; int ZEPHIR_LAST_CALL_STATUS; zval *options_param = NULL, *data = NULL, *file = NULL, *_0, *_2, _3 = zval_used_for_init, *_4 = NULL, *_5, *_6, *_7, *_8, *_10, _11 = zval_used_for_init, *_13, *_14 = NULL; zval *options = NULL, *_1; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &options_param); options = options_param; if (!(zephir_array_isset_string(options, SS("content")))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_translate_exception_ce, "Parameter 'content' is required", "phalcon/translate/adapter/csv.zep", 43); return; } ZEPHIR_INIT_VAR(_0); ZEPHIR_INIT_VAR(_1); zephir_create_array(_1, 3, 0 TSRMLS_CC); add_assoc_stringl_ex(_1, SS("delimiter"), SL(";"), 1); add_assoc_long_ex(_1, SS("length"), 0); add_assoc_stringl_ex(_1, SS("enclosure"), SL("\""), 1); zephir_fast_array_merge(_0, &(_1), &(options) TSRMLS_CC); ZEPHIR_CPY_WRT(options, _0); zephir_array_fetch_string(&_2, options, SL("content"), PH_NOISY | PH_READONLY, "phalcon/translate/adapter/csv.zep", 52 TSRMLS_CC); ZEPHIR_SINIT_VAR(_3); ZVAL_STRING(&_3, "rb", 0); ZEPHIR_CALL_FUNCTION(&file, "fopen", NULL, 291, _2, &_3); zephir_check_call_status(); if (Z_TYPE_P(file) != IS_RESOURCE) { ZEPHIR_INIT_VAR(_4); object_init_ex(_4, phalcon_translate_exception_ce); zephir_array_fetch_string(&_5, options, SL("content"), PH_NOISY | PH_READONLY, "phalcon/translate/adapter/csv.zep", 55 TSRMLS_CC); ZEPHIR_INIT_VAR(_6); ZEPHIR_CONCAT_SVS(_6, "Error opening translation file '", _5, "'"); ZEPHIR_CALL_METHOD(NULL, _4, "__construct", NULL, 9, _6); zephir_check_call_status(); zephir_throw_exception_debug(_4, "phalcon/translate/adapter/csv.zep", 55 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } while (1) { zephir_array_fetch_string(&_5, options, SL("length"), PH_NOISY | PH_READONLY, "phalcon/translate/adapter/csv.zep", 60 TSRMLS_CC); zephir_array_fetch_string(&_7, options, SL("delimiter"), PH_NOISY | PH_READONLY, "phalcon/translate/adapter/csv.zep", 60 TSRMLS_CC); zephir_array_fetch_string(&_8, options, SL("enclosure"), PH_NOISY | PH_READONLY, "phalcon/translate/adapter/csv.zep", 60 TSRMLS_CC); ZEPHIR_CALL_FUNCTION(&data, "fgetcsv", &_9, 422, file, _5, _7, _8); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(data)) { break; } zephir_array_fetch_long(&_10, data, 0, PH_NOISY | PH_READONLY, "phalcon/translate/adapter/csv.zep", 65 TSRMLS_CC); ZEPHIR_SINIT_NVAR(_3); ZVAL_LONG(&_3, 0); ZEPHIR_SINIT_NVAR(_11); ZVAL_LONG(&_11, 1); ZEPHIR_INIT_NVAR(_4); zephir_substr(_4, _10, 0 , 1 , 0); _12 = ZEPHIR_IS_STRING_IDENTICAL(_4, "#"); if (!(_12)) { _12 = !(zephir_array_isset_long(data, 1)); } if (_12) { continue; } zephir_array_fetch_long(&_13, data, 1, PH_NOISY | PH_READONLY, "phalcon/translate/adapter/csv.zep", 69 TSRMLS_CC); ZEPHIR_OBS_NVAR(_14); zephir_array_fetch_long(&_14, data, 0, PH_NOISY, "phalcon/translate/adapter/csv.zep", 69 TSRMLS_CC); zephir_update_property_array(this_ptr, SL("_translate"), _14, _13 TSRMLS_CC); } zephir_fclose(file TSRMLS_CC); ZEPHIR_MM_RESTORE(); }
/** * Sets the HTTP response code * *<code> * $response->setStatusCode(404, "Not Found"); *</code> */ PHP_METHOD(Phalcon_Http_Response, setStatusCode) { zval *_10; zephir_fcall_cache_entry *_7 = NULL, *_8 = NULL; zend_bool _4; HashTable *_2; HashPosition _1; zval *message = NULL, *_13, *_15; zval *code_param = NULL, *message_param = NULL, *headers = NULL, *currentHeadersRaw = NULL, *key = NULL, *defaultMessage, *_0 = NULL, **_3, _5 = zval_used_for_init, *_6 = NULL, *_9, *_11, *_12, _14; int code, ZEPHIR_LAST_CALL_STATUS; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &code_param, &message_param); code = zephir_get_intval(code_param); if (!message_param) { ZEPHIR_INIT_VAR(message); ZVAL_EMPTY_STRING(message); } else { zephir_get_strval(message, message_param); } ZEPHIR_CALL_METHOD(&headers, this_ptr, "getheaders", NULL, 0); zephir_check_call_status(); ZEPHIR_CALL_METHOD(¤tHeadersRaw, headers, "toarray", NULL, 0); zephir_check_call_status(); if (Z_TYPE_P(currentHeadersRaw) == IS_ARRAY) { ZEPHIR_INIT_VAR(_0); zephir_is_iterable(currentHeadersRaw, &_2, &_1, 0, 0, "phalcon/http/response.zep", 130); for ( ; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS ; zephir_hash_move_forward_ex(_2, &_1) ) { ZEPHIR_GET_HMKEY(key, _2, _1); ZEPHIR_GET_HVALUE(_0, _3); _4 = Z_TYPE_P(key) == IS_STRING; if (_4) { ZEPHIR_SINIT_NVAR(_5); ZVAL_STRING(&_5, "HTTP/", 0); ZEPHIR_CALL_FUNCTION(&_6, "strstr", &_7, 235, key, &_5); zephir_check_call_status(); _4 = zephir_is_true(_6); } if (_4) { ZEPHIR_CALL_METHOD(NULL, headers, "remove", &_8, 0, key); zephir_check_call_status(); } } } if (ZEPHIR_IS_STRING_IDENTICAL(message, "")) { ZEPHIR_OBS_VAR(_9); zephir_read_property_this(&_9, this_ptr, SL("_statusCodes"), PH_NOISY_CC); if (Z_TYPE_P(_9) != IS_ARRAY) { ZEPHIR_INIT_VAR(_10); zephir_create_array(_10, 59, 0 TSRMLS_CC); add_index_stringl(_10, 100, SL("Continue"), 1); add_index_stringl(_10, 101, SL("Switching Protocols"), 1); add_index_stringl(_10, 102, SL("Processing"), 1); add_index_stringl(_10, 200, SL("OK"), 1); add_index_stringl(_10, 201, SL("Created"), 1); add_index_stringl(_10, 202, SL("Accepted"), 1); add_index_stringl(_10, 203, SL("Non-Authoritative Information"), 1); add_index_stringl(_10, 204, SL("No Content"), 1); add_index_stringl(_10, 205, SL("Reset Content"), 1); add_index_stringl(_10, 206, SL("Partial Content"), 1); add_index_stringl(_10, 207, SL("Multi-status"), 1); add_index_stringl(_10, 208, SL("Already Reported"), 1); add_index_stringl(_10, 300, SL("Multiple Choices"), 1); add_index_stringl(_10, 301, SL("Moved Permanently"), 1); add_index_stringl(_10, 302, SL("Found"), 1); add_index_stringl(_10, 303, SL("See Other"), 1); add_index_stringl(_10, 304, SL("Not Modified"), 1); add_index_stringl(_10, 305, SL("Use Proxy"), 1); add_index_stringl(_10, 306, SL("Switch Proxy"), 1); add_index_stringl(_10, 307, SL("Temporary Redirect"), 1); add_index_stringl(_10, 400, SL("Bad Request"), 1); add_index_stringl(_10, 401, SL("Unauthorized"), 1); add_index_stringl(_10, 402, SL("Payment Required"), 1); add_index_stringl(_10, 403, SL("Forbidden"), 1); add_index_stringl(_10, 404, SL("Not Found"), 1); add_index_stringl(_10, 405, SL("Method Not Allowed"), 1); add_index_stringl(_10, 406, SL("Not Acceptable"), 1); add_index_stringl(_10, 407, SL("Proxy Authentication Required"), 1); add_index_stringl(_10, 408, SL("Request Time-out"), 1); add_index_stringl(_10, 409, SL("Conflict"), 1); add_index_stringl(_10, 410, SL("Gone"), 1); add_index_stringl(_10, 411, SL("Length Required"), 1); add_index_stringl(_10, 412, SL("Precondition Failed"), 1); add_index_stringl(_10, 413, SL("Request Entity Too Large"), 1); add_index_stringl(_10, 414, SL("Request-URI Too Large"), 1); add_index_stringl(_10, 415, SL("Unsupported Media Type"), 1); add_index_stringl(_10, 416, SL("Requested range not satisfiable"), 1); add_index_stringl(_10, 417, SL("Expectation Failed"), 1); add_index_stringl(_10, 418, SL("I'm a teapot"), 1); add_index_stringl(_10, 422, SL("Unprocessable Entity"), 1); add_index_stringl(_10, 423, SL("Locked"), 1); add_index_stringl(_10, 424, SL("Failed Dependency"), 1); add_index_stringl(_10, 425, SL("Unordered Collection"), 1); add_index_stringl(_10, 426, SL("Upgrade Required"), 1); add_index_stringl(_10, 428, SL("Precondition Required"), 1); add_index_stringl(_10, 429, SL("Too Many Requests"), 1); add_index_stringl(_10, 431, SL("Request Header Fields Too Large"), 1); add_index_stringl(_10, 500, SL("Internal Server Error"), 1); add_index_stringl(_10, 501, SL("Not Implemented"), 1); add_index_stringl(_10, 502, SL("Bad Gateway"), 1); add_index_stringl(_10, 503, SL("Service Unavailable"), 1); add_index_stringl(_10, 504, SL("Gateway Time-out"), 1); add_index_stringl(_10, 505, SL("HTTP Version not supported"), 1); add_index_stringl(_10, 506, SL("Variant Also Negotiates"), 1); add_index_stringl(_10, 507, SL("Insufficient Storage"), 1); add_index_stringl(_10, 508, SL("Loop Detected"), 1); add_index_stringl(_10, 511, SL("Network Authentication Required"), 1); zephir_update_property_this(this_ptr, SL("_statusCodes"), _10 TSRMLS_CC); } _11 = zephir_fetch_nproperty_this(this_ptr, SL("_statusCodes"), PH_NOISY_CC); if (!(zephir_array_isset_long(_11, code))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_http_response_exception_ce, "Non-standard statuscode given without a message", "phalcon/http/response.zep", 204); return; } _12 = zephir_fetch_nproperty_this(this_ptr, SL("_statusCodes"), PH_NOISY_CC); ZEPHIR_OBS_VAR(defaultMessage); zephir_array_fetch_long(&defaultMessage, _12, code, PH_NOISY, "phalcon/http/response.zep", 207 TSRMLS_CC); zephir_get_strval(message, defaultMessage); } ZEPHIR_SINIT_NVAR(_5); ZVAL_LONG(&_5, code); ZEPHIR_INIT_VAR(_13); ZEPHIR_CONCAT_SVSV(_13, "HTTP/1.1 ", &_5, " ", message); ZEPHIR_CALL_METHOD(NULL, headers, "setraw", NULL, 0, _13); zephir_check_call_status(); ZEPHIR_SINIT_VAR(_14); ZVAL_LONG(&_14, code); ZEPHIR_INIT_VAR(_15); ZEPHIR_CONCAT_VSV(_15, &_14, " ", message); ZEPHIR_INIT_NVAR(_0); ZVAL_STRING(_0, "Status", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, headers, "set", NULL, 0, _0, _15); zephir_check_temp_parameter(_0); zephir_check_call_status(); RETURN_THIS(); }
/** * Phalcon\Config\Adapter\Yaml constructor * * @throws \Phalcon\Config\Exception */ PHP_METHOD(Phalcon_Config_Adapter_Yaml, __construct) { zephir_fcall_cache_entry *_5 = NULL; zephir_nts_static zephir_fcall_cache_entry *_2 = NULL, *_7 = NULL, *_8 = NULL; int ndocs = 0, ZEPHIR_LAST_CALL_STATUS; zval *callbacks = NULL; zval *filePath_param = NULL, *callbacks_param = NULL, *yamlConfig = NULL, _0, *_1 = NULL, *_3 = NULL, *_4 = NULL, *_6; zval *filePath = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &filePath_param, &callbacks_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); } if (!callbacks_param) { ZEPHIR_INIT_VAR(callbacks); array_init(callbacks); } else { callbacks = callbacks_param; } ZEPHIR_SINIT_VAR(_0); ZVAL_STRING(&_0, "yaml", 0); ZEPHIR_CALL_FUNCTION(&_1, "extension_loaded", &_2, &_0); zephir_check_call_status(); if (!(zephir_is_true(_1))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_config_exception_ce, "Yaml extension not loaded", "phalcon/config/adapter/yaml.zep", 62); return; } if (!ZEPHIR_IS_STRING_IDENTICAL(callbacks, "")) { ZEPHIR_INIT_VAR(_3); ZVAL_LONG(_3, 0); ZEPHIR_INIT_VAR(_4); ZVAL_LONG(_4, ndocs); Z_SET_ISREF_P(_4); ZEPHIR_CALL_FUNCTION(&yamlConfig, "yaml_parse_file", &_5, filePath, _3, _4, callbacks); Z_UNSET_ISREF_P(_4); zephir_check_call_status(); } else { ZEPHIR_CALL_FUNCTION(&yamlConfig, "yaml_parse_file", &_5, filePath); zephir_check_call_status(); } if (ZEPHIR_IS_FALSE_IDENTICAL(yamlConfig)) { ZEPHIR_INIT_NVAR(_3); object_init_ex(_3, phalcon_config_exception_ce); ZEPHIR_INIT_NVAR(_4); zephir_basename(_4, filePath TSRMLS_CC); ZEPHIR_INIT_VAR(_6); ZEPHIR_CONCAT_SVS(_6, "Configuration file ", _4, " can't be loaded"); ZEPHIR_CALL_METHOD(NULL, _3, "__construct", &_7, _6); zephir_check_call_status(); zephir_throw_exception_debug(_3, "phalcon/config/adapter/yaml.zep", 72 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; } ZEPHIR_CALL_PARENT(NULL, phalcon_config_adapter_yaml_ce, this_ptr, "__construct", &_8, yamlConfig); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); }
/** * Transforms an intermediate representation for a expression into a database system valid expression * * @param array expression * @param string escapeChar * @return string */ PHP_METHOD(Pdm_Db_AbstractDialect, getSqlExpression) { zephir_fcall_cache_entry *_10 = NULL; HashTable *_7, *_13; HashPosition _6, _12; int ZEPHIR_LAST_CALL_STATUS; zval *escapeChar = NULL, *_1 = NULL; zval *expression, *escapeChar_param = NULL, *type, *domain, *operator, *left = NULL, *right = NULL, *name = NULL, *sqlItems, *escapedName = NULL, *sqlArguments, *arguments, *argument = NULL, *item = NULL, *_0, *_2, *_3, *_4, *_5 = NULL, **_8, *_9 = NULL, *_11 = NULL, **_14, *_15, *_16; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &expression, &escapeChar_param); if (!escapeChar_param) { ZEPHIR_INIT_VAR(escapeChar); ZVAL_EMPTY_STRING(escapeChar); } else { zephir_get_strval(escapeChar, escapeChar_param); } if (ZEPHIR_GLOBAL(db).escape_identifiers) { if (ZEPHIR_IS_STRING_IDENTICAL(escapeChar, "")) { ZEPHIR_OBS_VAR(_0); zephir_read_property_this(&_0, this_ptr, SL("escapeChar"), PH_NOISY_CC); zephir_get_strval(_1, _0); ZEPHIR_CPY_WRT(escapeChar, _1); } } if (Z_TYPE_P(expression) != IS_ARRAY) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(pdm_db_exception_ce, "Invalid SQL expression", "pdm/db/abstractdialect.zep", 176); return; } ZEPHIR_OBS_VAR(type); if (!(zephir_array_isset_string_fetch(&type, expression, SS("type"), 0 TSRMLS_CC))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(pdm_db_exception_ce, "Invalid SQL expression", "pdm/db/abstractdialect.zep", 180); return; } if (ZEPHIR_IS_STRING(type, "qualified")) { ZEPHIR_OBS_VAR(name); zephir_array_fetch_string(&name, expression, SL("name"), PH_NOISY TSRMLS_CC); if (ZEPHIR_GLOBAL(db).escape_identifiers) { ZEPHIR_INIT_VAR(escapedName); ZEPHIR_CONCAT_VVV(escapedName, escapeChar, name, escapeChar); } else { ZEPHIR_CPY_WRT(escapedName, name); } ZEPHIR_OBS_VAR(domain); if (zephir_array_isset_string_fetch(&domain, expression, SS("domain"), 0 TSRMLS_CC)) { if (ZEPHIR_GLOBAL(db).escape_identifiers) { ZEPHIR_CONCAT_VVVSV(return_value, escapeChar, domain, escapeChar, ".", escapedName); RETURN_MM(); } else { ZEPHIR_CONCAT_VSV(return_value, domain, ".", escapedName); RETURN_MM(); } } RETURN_CCTOR(escapedName); } if (ZEPHIR_IS_STRING(type, "literal")) { zephir_array_fetch_string(&_2, expression, SL("value"), PH_NOISY | PH_READONLY TSRMLS_CC); RETURN_CTOR(_2); } if (ZEPHIR_IS_STRING(type, "binary-op")) { zephir_array_fetch_string(&_2, expression, SL("left"), PH_NOISY | PH_READONLY TSRMLS_CC); ZEPHIR_CALL_METHOD(&left, this_ptr, "getsqlexpression", NULL, _2, escapeChar); zephir_check_call_status(); zephir_array_fetch_string(&_3, expression, SL("right"), PH_NOISY | PH_READONLY TSRMLS_CC); ZEPHIR_CALL_METHOD(&right, this_ptr, "getsqlexpression", NULL, _3, escapeChar); zephir_check_call_status(); zephir_array_fetch_string(&_4, expression, SL("op"), PH_NOISY | PH_READONLY TSRMLS_CC); ZEPHIR_CONCAT_VSVSV(return_value, left, " ", _4, " ", right); RETURN_MM(); } if (ZEPHIR_IS_STRING(type, "unary-op")) { ZEPHIR_OBS_VAR(operator); zephir_array_fetch_string(&operator, expression, SL("op"), PH_NOISY TSRMLS_CC); ZEPHIR_OBS_NVAR(left); if (zephir_array_isset_string_fetch(&left, expression, SS("left"), 0 TSRMLS_CC)) { ZEPHIR_CALL_METHOD(&_5, this_ptr, "getsqlexpression", NULL, left, escapeChar); zephir_check_call_status(); ZEPHIR_CONCAT_VV(return_value, _5, operator); RETURN_MM(); } ZEPHIR_OBS_NVAR(right); if (zephir_array_isset_string_fetch(&right, expression, SS("right"), 0 TSRMLS_CC)) { ZEPHIR_CALL_METHOD(&_5, this_ptr, "getsqlexpression", NULL, right, escapeChar); zephir_check_call_status(); ZEPHIR_CONCAT_VV(return_value, _5, operator); RETURN_MM(); } } if (ZEPHIR_IS_STRING(type, "placeholder")) { zephir_array_fetch_string(&_2, expression, SL("value"), PH_NOISY | PH_READONLY TSRMLS_CC); RETURN_CTOR(_2); } if (ZEPHIR_IS_STRING(type, "parentheses")) { zephir_array_fetch_string(&_2, expression, SL("left"), PH_NOISY | PH_READONLY TSRMLS_CC); ZEPHIR_CALL_METHOD(&_5, this_ptr, "getsqlexpression", NULL, _2, escapeChar); zephir_check_call_status(); ZEPHIR_CONCAT_SVS(return_value, "(", _5, ")"); RETURN_MM(); } if (ZEPHIR_IS_STRING(type, "functionCall")) { ZEPHIR_OBS_NVAR(name); zephir_array_fetch_string(&name, expression, SL("name"), PH_NOISY TSRMLS_CC); ZEPHIR_INIT_VAR(sqlArguments); array_init(sqlArguments); ZEPHIR_OBS_VAR(arguments); if (zephir_array_isset_string_fetch(&arguments, expression, SS("arguments"), 0 TSRMLS_CC)) { zephir_is_iterable(arguments, &_7, &_6, 0, 0); for ( ; zephir_hash_get_current_data_ex(_7, (void**) &_8, &_6) == SUCCESS ; zephir_hash_move_forward_ex(_7, &_6) ) { ZEPHIR_GET_HVALUE(argument, _8); ZEPHIR_CALL_METHOD(&_9, this_ptr, "getsqlexpression", &_10, argument, escapeChar); zephir_check_call_status(); zephir_array_append(&sqlArguments, _9, PH_SEPARATE); } ZEPHIR_INIT_VAR(_11); zephir_fast_join_str(_11, SL(", "), sqlArguments TSRMLS_CC); ZEPHIR_CONCAT_VSVS(return_value, name, "(", _11, ")"); RETURN_MM(); } else { ZEPHIR_CONCAT_VS(return_value, name, "()"); RETURN_MM(); } } if (ZEPHIR_IS_STRING(type, "list")) { ZEPHIR_INIT_VAR(sqlItems); array_init(sqlItems); zephir_array_fetch_long(&_2, expression, 0, PH_NOISY | PH_READONLY TSRMLS_CC); zephir_is_iterable(_2, &_13, &_12, 0, 0); for ( ; zephir_hash_get_current_data_ex(_13, (void**) &_14, &_12) == SUCCESS ; zephir_hash_move_forward_ex(_13, &_12) ) { ZEPHIR_GET_HVALUE(item, _14); ZEPHIR_CALL_METHOD(&_5, this_ptr, "getsqlexpression", &_10, item, escapeChar); zephir_check_call_status(); zephir_array_append(&sqlItems, _5, PH_SEPARATE); } ZEPHIR_INIT_NVAR(_11); zephir_fast_join_str(_11, SL(", "), sqlItems TSRMLS_CC); ZEPHIR_CONCAT_SVS(return_value, "(", _11, ")"); RETURN_MM(); } if (ZEPHIR_IS_STRING(type, "all")) { RETURN_MM_STRING("*", 1); } if (ZEPHIR_IS_STRING(type, "cast")) { zephir_array_fetch_string(&_2, expression, SL("left"), PH_NOISY | PH_READONLY TSRMLS_CC); ZEPHIR_CALL_METHOD(&left, this_ptr, "getsqlexpression", &_10, _2, escapeChar); zephir_check_call_status(); zephir_array_fetch_string(&_3, expression, SL("right"), PH_NOISY | PH_READONLY TSRMLS_CC); ZEPHIR_CALL_METHOD(&right, this_ptr, "getsqlexpression", &_10, _3, escapeChar); zephir_check_call_status(); ZEPHIR_CONCAT_SVSVS(return_value, "CAST(", left, " AS ", right, ")"); RETURN_MM(); } if (ZEPHIR_IS_STRING(type, "convert")) { zephir_array_fetch_string(&_2, expression, SL("left"), PH_NOISY | PH_READONLY TSRMLS_CC); ZEPHIR_CALL_METHOD(&left, this_ptr, "getsqlexpression", &_10, _2, escapeChar); zephir_check_call_status(); zephir_array_fetch_string(&_3, expression, SL("right"), PH_NOISY | PH_READONLY TSRMLS_CC); ZEPHIR_CALL_METHOD(&right, this_ptr, "getsqlexpression", &_10, _3, escapeChar); zephir_check_call_status(); ZEPHIR_CONCAT_SVSVS(return_value, "CONVERT(", left, " USING ", right, ")"); RETURN_MM(); } ZEPHIR_INIT_VAR(_15); object_init_ex(_15, pdm_db_exception_ce); ZEPHIR_INIT_VAR(_16); ZEPHIR_CONCAT_SVS(_16, "Invalid SQL expression type '", type, "'"); ZEPHIR_CALL_METHOD(NULL, _15, "__construct", NULL, _16); zephir_check_call_status(); zephir_throw_exception_debug(_15, "pdm/db/abstractdialect.zep", 287 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; }
/** * Encrypts a text * *<code> * $encrypted = $crypt->encrypt("Ultra-secret text", "encrypt password"); *</code> */ PHP_METHOD(Phalcon_Crypt, encrypt) { zend_bool _8, _9; zephir_fcall_cache_entry *_4 = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; zval *text_param = NULL, *key_param = NULL, *encryptKey = NULL, *ivSize = NULL, *iv = NULL, *cipher = NULL, *mode = NULL, *blockSize = NULL, *paddingType = NULL, *padded = NULL, _0 = zval_used_for_init, *_1 = NULL, *_2, *_3 = NULL, _10, *_11 = NULL, *_5$$9, *_6$$9, *_7$$9 = NULL; zval *text = NULL, *key = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &text_param, &key_param); if (UNEXPECTED(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 (EXPECTED(Z_TYPE_P(text_param) == IS_STRING)) { zephir_get_strval(text, text_param); } else { ZEPHIR_INIT_VAR(text); ZVAL_EMPTY_STRING(text); } if (!key_param) { ZEPHIR_INIT_VAR(key); ZVAL_EMPTY_STRING(key); } else { if (UNEXPECTED(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 (EXPECTED(Z_TYPE_P(key_param) == IS_STRING)) { zephir_get_strval(key, key_param); } else { ZEPHIR_INIT_VAR(key); ZVAL_EMPTY_STRING(key); } } if (!((zephir_function_exists_ex(SS("openssl_cipher_iv_length") TSRMLS_CC) == SUCCESS))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "openssl extension is required", "phalcon/crypt.zep", 280); return; } if (ZEPHIR_IS_STRING_IDENTICAL(key, "")) { ZEPHIR_OBS_VAR(encryptKey); zephir_read_property_this(&encryptKey, this_ptr, SL("_key"), PH_NOISY_CC); } else { ZEPHIR_CPY_WRT(encryptKey, key); } if (ZEPHIR_IS_EMPTY(encryptKey)) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Encryption key cannot be empty", "phalcon/crypt.zep", 290); return; } ZEPHIR_OBS_VAR(cipher); zephir_read_property_this(&cipher, this_ptr, SL("_cipher"), PH_NOISY_CC); ZEPHIR_SINIT_VAR(_0); ZVAL_STRING(&_0, "-", 0); ZEPHIR_CALL_FUNCTION(&_1, "strrpos", NULL, 152, cipher, &_0); zephir_check_call_status(); ZEPHIR_SINIT_NVAR(_0); ZVAL_LONG(&_0, (zephir_get_numberval(_1) - zephir_fast_strlen_ev(cipher))); ZEPHIR_INIT_VAR(_2); zephir_substr(_2, cipher, zephir_get_intval(&_0), 0, ZEPHIR_SUBSTR_NO_LENGTH); ZEPHIR_INIT_VAR(mode); zephir_fast_strtolower(mode, _2); ZEPHIR_CALL_FUNCTION(&_3, "openssl_get_cipher_methods", NULL, 153, ZEPHIR_GLOBAL(global_true)); zephir_check_call_status(); if (!(zephir_fast_in_array(cipher, _3 TSRMLS_CC))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Cipher algorithm is unknown", "phalcon/crypt.zep", 297); return; } ZEPHIR_CALL_FUNCTION(&ivSize, "openssl_cipher_iv_length", &_4, 154, cipher); zephir_check_call_status(); if (ZEPHIR_GT_LONG(ivSize, 0)) { ZEPHIR_CPY_WRT(blockSize, ivSize); } else { ZEPHIR_INIT_VAR(_5$$9); ZEPHIR_CONCAT_SV(_5$$9, "-", mode); ZEPHIR_INIT_VAR(_6$$9); ZVAL_STRING(_6$$9, "", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_FUNCTION(&_7$$9, "str_ireplace", NULL, 155, _5$$9, _6$$9, cipher); zephir_check_temp_parameter(_6$$9); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(&blockSize, "openssl_cipher_iv_length", &_4, 154, _7$$9); zephir_check_call_status(); } ZEPHIR_CALL_FUNCTION(&iv, "openssl_random_pseudo_bytes", NULL, 156, ivSize); zephir_check_call_status(); ZEPHIR_OBS_VAR(paddingType); zephir_read_property_this(&paddingType, this_ptr, SL("_padding"), PH_NOISY_CC); _8 = !ZEPHIR_IS_LONG(paddingType, 0); if (_8) { _9 = ZEPHIR_IS_STRING(mode, "cbc"); if (!(_9)) { _9 = ZEPHIR_IS_STRING(mode, "ecb"); } _8 = _9; } if (_8) { ZEPHIR_CALL_METHOD(&padded, this_ptr, "_cryptpadtext", NULL, 0, text, mode, blockSize, paddingType); zephir_check_call_status(); } else { ZEPHIR_CPY_WRT(padded, text); } ZEPHIR_SINIT_VAR(_10); ZVAL_LONG(&_10, 1); ZEPHIR_CALL_FUNCTION(&_11, "openssl_encrypt", NULL, 157, padded, cipher, encryptKey, &_10, iv); zephir_check_call_status(); ZEPHIR_CONCAT_VV(return_value, iv, _11); RETURN_MM(); }
PHP_METHOD(Xs_Command, __construct) { int ZEPHIR_LAST_CALL_STATUS; zephir_fcall_cache_entry *_5 = NULL; zend_bool _3; HashTable *_1; HashPosition _0; zval *buf = NULL, *buf1 = NULL; long arg1, arg2; zval *cmd, *arg1_param = NULL, *arg2_param = NULL, *buf_param = NULL, *buf1_param = NULL, *k = NULL, *v = NULL, **_2, *_4 = NULL, *_6; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 4, &cmd, &arg1_param, &arg2_param, &buf_param, &buf1_param); if (!arg1_param) { arg1 = 0; } else { arg1 = zephir_get_intval(arg1_param); } if (!arg2_param) { arg2 = 0; } else { arg2 = zephir_get_intval(arg2_param); } if (!buf_param) { ZEPHIR_INIT_VAR(buf); ZVAL_STRING(buf, "", 1); } else { zephir_get_strval(buf, buf_param); } if (!buf1_param) { ZEPHIR_INIT_VAR(buf1); ZVAL_STRING(buf1, "", 1); } else { zephir_get_strval(buf1, buf1_param); } if (Z_TYPE_P(cmd) == IS_ARRAY) { zephir_is_iterable(cmd, &_1, &_0, 0, 0, "xs/command.zep", 188); for ( ; zephir_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS ; zephir_hash_move_forward_ex(_1, &_0) ) { ZEPHIR_GET_HMKEY(k, _1, _0); ZEPHIR_GET_HVALUE(v, _2); _3 = ZEPHIR_IS_STRING_IDENTICAL(k, "arg"); if (!(_3)) { ZEPHIR_CALL_FUNCTION(&_4, "property_exists", &_5, 1, this_ptr, k); zephir_check_call_status(); _3 = zephir_is_true(_4); } if (_3) { zephir_update_property_zval_zval(this_ptr, k, v TSRMLS_CC); } } } else { zephir_update_property_this(this_ptr, SL("cmd"), cmd TSRMLS_CC); ZEPHIR_INIT_ZVAL_NREF(_6); ZVAL_LONG(_6, arg1); zephir_update_property_this(this_ptr, SL("arg1"), _6 TSRMLS_CC); ZEPHIR_INIT_ZVAL_NREF(_6); ZVAL_LONG(_6, arg2); zephir_update_property_this(this_ptr, SL("arg2"), _6 TSRMLS_CC); zephir_update_property_this(this_ptr, SL("buf"), buf TSRMLS_CC); zephir_update_property_this(this_ptr, SL("buf1"), buf1 TSRMLS_CC); } ZEPHIR_MM_RESTORE(); }
/** * Handles routing information received from the rewrite engine * *<code> * //Read the info from the rewrite engine * $router->handle(); * * //Manually passing an URL * $router->handle('/posts/edit/1'); *</code> */ PHP_METHOD(Phalcon_Mvc_Router, handle) { zval *_21$$28 = NULL, *_28$$37 = NULL, *_30$$40 = NULL; HashTable *_6, *_25$$33; HashPosition _5, _24$$33; zend_bool _1; zephir_fcall_cache_entry *_18 = NULL, *_20 = NULL, *_23 = NULL, *_31 = NULL; int ZEPHIR_LAST_CALL_STATUS; zval *uri_param = NULL, *realUri = NULL, *request = NULL, *currentHostName = NULL, *routeFound = NULL, *parts = NULL, *params = NULL, *matches = NULL, *notFoundPaths = NULL, *vnamespace = NULL, *module = NULL, *controller = NULL, *action = NULL, *paramsStr = NULL, *strParams = NULL, *route = NULL, *methods = NULL, *dependencyInjector = NULL, *hostname = NULL, *regexHostName = NULL, *matched = NULL, *pattern = NULL, *handledUri = NULL, *beforeMatch = NULL, *paths = NULL, *converters = NULL, *part = NULL, *position = NULL, *matchPosition = NULL, *converter = NULL, *eventsManager = NULL, *_0, *_4, **_7, *_32, *_33, *_34, *_35, *_36, _2$$5, *_3$$7, *_8$$10, *_9$$10 = NULL, *_10$$10 = NULL, *_11$$9 = NULL, *_12$$9 = NULL, *_13$$14, *_14$$14 = NULL, *_15$$14 = NULL, *_16$$18 = NULL, *_17$$23 = NULL, *_19$$27 = NULL, *_22$$31 = NULL, **_26$$33, *_27$$37 = NULL, *_29$$40 = NULL, _37$$55, *_38$$57, *_39$$59; zval *uri = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &uri_param); if (!uri_param) { ZEPHIR_INIT_VAR(uri); ZVAL_EMPTY_STRING(uri); } else { zephir_get_strval(uri, uri_param); } if (!(!(!uri) && Z_STRLEN_P(uri))) { ZEPHIR_CALL_METHOD(&realUri, this_ptr, "getrewriteuri", NULL, 0); zephir_check_call_status(); } else { ZEPHIR_CPY_WRT(realUri, uri); } _0 = zephir_fetch_nproperty_this(this_ptr, SL("_removeExtraSlashes"), PH_NOISY_CC); _1 = zephir_is_true(_0); if (_1) { _1 = !ZEPHIR_IS_STRING(realUri, "/"); } if (_1) { ZEPHIR_SINIT_VAR(_2$$5); ZVAL_STRING(&_2$$5, "/", 0); ZEPHIR_INIT_VAR(handledUri); zephir_fast_trim(handledUri, realUri, &_2$$5, ZEPHIR_TRIM_RIGHT TSRMLS_CC); } else { ZEPHIR_CPY_WRT(handledUri, realUri); } ZEPHIR_INIT_VAR(request); ZVAL_NULL(request); ZEPHIR_INIT_VAR(currentHostName); ZVAL_NULL(currentHostName); ZEPHIR_INIT_VAR(routeFound); ZVAL_BOOL(routeFound, 0); ZEPHIR_INIT_VAR(parts); array_init(parts); ZEPHIR_INIT_VAR(params); array_init(params); ZEPHIR_INIT_VAR(matches); ZVAL_NULL(matches); if (0) { zephir_update_property_this(this_ptr, SL("_wasMatched"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC); } else { zephir_update_property_this(this_ptr, SL("_wasMatched"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC); } zephir_update_property_this(this_ptr, SL("_matchedRoute"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC); ZEPHIR_OBS_VAR(eventsManager); zephir_read_property_this(&eventsManager, this_ptr, SL("_eventsManager"), PH_NOISY_CC); if (Z_TYPE_P(eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(_3$$7); ZVAL_STRING(_3$$7, "router:beforeCheckRoutes", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, 0, _3$$7, this_ptr); zephir_check_temp_parameter(_3$$7); zephir_check_call_status(); } _4 = zephir_fetch_nproperty_this(this_ptr, SL("_routes"), PH_NOISY_CC); zephir_is_iterable(_4, &_6, &_5, 0, 1, "phalcon/mvc/router.zep", 558); for ( ; zephir_hash_get_current_data_ex(_6, (void**) &_7, &_5) == SUCCESS ; zephir_hash_move_backwards_ex(_6, &_5) ) { ZEPHIR_GET_HVALUE(route, _7); ZEPHIR_INIT_NVAR(params); array_init(params); ZEPHIR_INIT_NVAR(matches); ZVAL_NULL(matches); ZEPHIR_CALL_METHOD(&methods, route, "gethttpmethods", NULL, 0); zephir_check_call_status(); if (Z_TYPE_P(methods) != IS_NULL) { if (Z_TYPE_P(request) == IS_NULL) { _8$$10 = zephir_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY_CC); ZEPHIR_CPY_WRT(dependencyInjector, _8$$10); if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_router_exception_ce, "A dependency injection container is required to access the 'request' service", "phalcon/mvc/router.zep", 384); return; } ZEPHIR_INIT_NVAR(_10$$10); ZVAL_STRING(_10$$10, "request", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_9$$10, dependencyInjector, "getshared", NULL, 0, _10$$10); zephir_check_temp_parameter(_10$$10); zephir_check_call_status(); ZEPHIR_CPY_WRT(request, _9$$10); } ZEPHIR_INIT_NVAR(_12$$9); ZVAL_BOOL(_12$$9, 1); ZEPHIR_CALL_METHOD(&_11$$9, request, "ismethod", NULL, 0, methods, _12$$9); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(_11$$9)) { continue; } } ZEPHIR_CALL_METHOD(&hostname, route, "gethostname", NULL, 0); zephir_check_call_status(); if (Z_TYPE_P(hostname) != IS_NULL) { if (Z_TYPE_P(request) == IS_NULL) { _13$$14 = zephir_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY_CC); ZEPHIR_CPY_WRT(dependencyInjector, _13$$14); if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_router_exception_ce, "A dependency injection container is required to access the 'request' service", "phalcon/mvc/router.zep", 411); return; } ZEPHIR_INIT_NVAR(_15$$14); ZVAL_STRING(_15$$14, "request", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_14$$14, dependencyInjector, "getshared", NULL, 0, _15$$14); zephir_check_temp_parameter(_15$$14); zephir_check_call_status(); ZEPHIR_CPY_WRT(request, _14$$14); } if (Z_TYPE_P(currentHostName) != IS_OBJECT) { ZEPHIR_CALL_METHOD(¤tHostName, request, "gethttphost", NULL, 0); zephir_check_call_status(); } if (Z_TYPE_P(currentHostName) == IS_NULL) { continue; } if (zephir_memnstr_str(hostname, SL("("), "phalcon/mvc/router.zep", 434)) { if (!(zephir_memnstr_str(hostname, SL("#"), "phalcon/mvc/router.zep", 435))) { ZEPHIR_INIT_NVAR(regexHostName); ZEPHIR_CONCAT_SVS(regexHostName, "#^", hostname, "$#"); } else { ZEPHIR_CPY_WRT(regexHostName, hostname); } ZEPHIR_INIT_NVAR(_16$$18); ZEPHIR_INIT_NVAR(matched); zephir_preg_match(matched, regexHostName, currentHostName, _16$$18, 0, 0 , 0 TSRMLS_CC); } else { ZEPHIR_INIT_NVAR(matched); ZVAL_BOOL(matched, ZEPHIR_IS_EQUAL(currentHostName, hostname)); } if (!(zephir_is_true(matched))) { continue; } } if (Z_TYPE_P(eventsManager) == IS_OBJECT) { ZEPHIR_INIT_NVAR(_17$$23); ZVAL_STRING(_17$$23, "router:beforeCheckRoute", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", &_18, 0, _17$$23, this_ptr, route); zephir_check_temp_parameter(_17$$23); zephir_check_call_status(); } ZEPHIR_CALL_METHOD(&pattern, route, "getcompiledpattern", NULL, 0); zephir_check_call_status(); if (zephir_memnstr_str(pattern, SL("^"), "phalcon/mvc/router.zep", 459)) { ZEPHIR_INIT_NVAR(routeFound); zephir_preg_match(routeFound, pattern, handledUri, matches, 0, 0 , 0 TSRMLS_CC); } else { ZEPHIR_INIT_NVAR(routeFound); ZVAL_BOOL(routeFound, ZEPHIR_IS_EQUAL(pattern, handledUri)); } if (zephir_is_true(routeFound)) { if (Z_TYPE_P(eventsManager) == IS_OBJECT) { ZEPHIR_INIT_NVAR(_19$$27); ZVAL_STRING(_19$$27, "router:matchedRoute", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", &_20, 0, _19$$27, this_ptr, route); zephir_check_temp_parameter(_19$$27); zephir_check_call_status(); } ZEPHIR_CALL_METHOD(&beforeMatch, route, "getbeforematch", NULL, 0); zephir_check_call_status(); if (Z_TYPE_P(beforeMatch) != IS_NULL) { if (!(zephir_is_callable(beforeMatch TSRMLS_CC))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_router_exception_ce, "Before-Match callback is not callable in matched route", "phalcon/mvc/router.zep", 481); return; } ZEPHIR_INIT_NVAR(_21$$28); zephir_create_array(_21$$28, 3, 0 TSRMLS_CC); zephir_array_fast_append(_21$$28, handledUri); zephir_array_fast_append(_21$$28, route); zephir_array_fast_append(_21$$28, this_ptr); ZEPHIR_INIT_NVAR(routeFound); ZEPHIR_CALL_USER_FUNC_ARRAY(routeFound, beforeMatch, _21$$28); zephir_check_call_status(); } } else { if (Z_TYPE_P(eventsManager) == IS_OBJECT) { ZEPHIR_INIT_NVAR(_22$$31); ZVAL_STRING(_22$$31, "router:notMatchedRoute", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&routeFound, eventsManager, "fire", &_23, 0, _22$$31, this_ptr, route); zephir_check_temp_parameter(_22$$31); zephir_check_call_status(); } } if (zephir_is_true(routeFound)) { ZEPHIR_CALL_METHOD(&paths, route, "getpaths", NULL, 0); zephir_check_call_status(); ZEPHIR_CPY_WRT(parts, paths); if (Z_TYPE_P(matches) == IS_ARRAY) { ZEPHIR_CALL_METHOD(&converters, route, "getconverters", NULL, 0); zephir_check_call_status(); zephir_is_iterable(paths, &_25$$33, &_24$$33, 0, 0, "phalcon/mvc/router.zep", 547); for ( ; zephir_hash_get_current_data_ex(_25$$33, (void**) &_26$$33, &_24$$33) == SUCCESS ; zephir_hash_move_forward_ex(_25$$33, &_24$$33) ) { ZEPHIR_GET_HMKEY(part, _25$$33, _24$$33); ZEPHIR_GET_HVALUE(position, _26$$33); ZEPHIR_OBS_NVAR(matchPosition); if (zephir_array_isset_fetch(&matchPosition, matches, position, 0 TSRMLS_CC)) { if (Z_TYPE_P(converters) == IS_ARRAY) { ZEPHIR_OBS_NVAR(converter); if (zephir_array_isset_fetch(&converter, converters, part, 0 TSRMLS_CC)) { ZEPHIR_INIT_NVAR(_27$$37); ZEPHIR_INIT_NVAR(_28$$37); zephir_create_array(_28$$37, 1, 0 TSRMLS_CC); zephir_array_fast_append(_28$$37, matchPosition); ZEPHIR_CALL_USER_FUNC_ARRAY(_27$$37, converter, _28$$37); zephir_check_call_status(); zephir_array_update_zval(&parts, part, &_27$$37, PH_COPY | PH_SEPARATE); continue; } } zephir_array_update_zval(&parts, part, &matchPosition, PH_COPY | PH_SEPARATE); } else { if (Z_TYPE_P(converters) == IS_ARRAY) { ZEPHIR_OBS_NVAR(converter); if (zephir_array_isset_fetch(&converter, converters, part, 0 TSRMLS_CC)) { ZEPHIR_INIT_NVAR(_29$$40); ZEPHIR_INIT_NVAR(_30$$40); zephir_create_array(_30$$40, 1, 0 TSRMLS_CC); zephir_array_fast_append(_30$$40, position); ZEPHIR_CALL_USER_FUNC_ARRAY(_29$$40, converter, _30$$40); zephir_check_call_status(); zephir_array_update_zval(&parts, part, &_29$$40, PH_COPY | PH_SEPARATE); } } } } zephir_update_property_this(this_ptr, SL("_matches"), matches TSRMLS_CC); } zephir_update_property_this(this_ptr, SL("_matchedRoute"), route TSRMLS_CC); break; } } if (zephir_is_true(routeFound)) { if (1) { zephir_update_property_this(this_ptr, SL("_wasMatched"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC); } else { zephir_update_property_this(this_ptr, SL("_wasMatched"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC); } } else { if (0) { zephir_update_property_this(this_ptr, SL("_wasMatched"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC); } else { zephir_update_property_this(this_ptr, SL("_wasMatched"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC); } } if (!(zephir_is_true(routeFound))) { ZEPHIR_OBS_VAR(notFoundPaths); zephir_read_property_this(¬FoundPaths, this_ptr, SL("_notFoundPaths"), PH_NOISY_CC); if (Z_TYPE_P(notFoundPaths) != IS_NULL) { ZEPHIR_CALL_CE_STATIC(&parts, phalcon_mvc_router_route_ce, "getroutepaths", &_31, 79, notFoundPaths); zephir_check_call_status(); ZEPHIR_INIT_NVAR(routeFound); ZVAL_BOOL(routeFound, 1); } } _32 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultNamespace"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("_namespace"), _32 TSRMLS_CC); _33 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultModule"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("_module"), _33 TSRMLS_CC); _34 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultController"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("_controller"), _34 TSRMLS_CC); _35 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultAction"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("_action"), _35 TSRMLS_CC); _36 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultParams"), PH_NOISY_CC); zephir_update_property_this(this_ptr, SL("_params"), _36 TSRMLS_CC); if (zephir_is_true(routeFound)) { ZEPHIR_OBS_VAR(vnamespace); if (zephir_array_isset_string_fetch(&vnamespace, parts, SS("namespace"), 0 TSRMLS_CC)) { if (!(zephir_is_numeric(vnamespace))) { zephir_update_property_this(this_ptr, SL("_namespace"), vnamespace TSRMLS_CC); } zephir_array_unset_string(&parts, SS("namespace"), PH_SEPARATE); } ZEPHIR_OBS_VAR(module); if (zephir_array_isset_string_fetch(&module, parts, SS("module"), 0 TSRMLS_CC)) { if (!(zephir_is_numeric(module))) { zephir_update_property_this(this_ptr, SL("_module"), module TSRMLS_CC); } zephir_array_unset_string(&parts, SS("module"), PH_SEPARATE); } ZEPHIR_OBS_VAR(controller); if (zephir_array_isset_string_fetch(&controller, parts, SS("controller"), 0 TSRMLS_CC)) { if (!(zephir_is_numeric(controller))) { zephir_update_property_this(this_ptr, SL("_controller"), controller TSRMLS_CC); } zephir_array_unset_string(&parts, SS("controller"), PH_SEPARATE); } ZEPHIR_OBS_VAR(action); if (zephir_array_isset_string_fetch(&action, parts, SS("action"), 0 TSRMLS_CC)) { if (!(zephir_is_numeric(action))) { zephir_update_property_this(this_ptr, SL("_action"), action TSRMLS_CC); } zephir_array_unset_string(&parts, SS("action"), PH_SEPARATE); } ZEPHIR_OBS_VAR(paramsStr); if (zephir_array_isset_string_fetch(¶msStr, parts, SS("params"), 0 TSRMLS_CC)) { if (Z_TYPE_P(paramsStr) == IS_STRING) { ZEPHIR_SINIT_VAR(_37$$55); ZVAL_STRING(&_37$$55, "/", 0); ZEPHIR_INIT_VAR(strParams); zephir_fast_trim(strParams, paramsStr, &_37$$55, ZEPHIR_TRIM_BOTH TSRMLS_CC); if (!ZEPHIR_IS_STRING_IDENTICAL(strParams, "")) { ZEPHIR_INIT_NVAR(params); zephir_fast_explode_str(params, SL("/"), strParams, LONG_MAX TSRMLS_CC); } } zephir_array_unset_string(&parts, SS("params"), PH_SEPARATE); } if (zephir_fast_count_int(params TSRMLS_CC)) { ZEPHIR_INIT_VAR(_38$$57); zephir_fast_array_merge(_38$$57, &(params), &(parts) TSRMLS_CC); zephir_update_property_this(this_ptr, SL("_params"), _38$$57 TSRMLS_CC); } else { zephir_update_property_this(this_ptr, SL("_params"), parts TSRMLS_CC); } } if (Z_TYPE_P(eventsManager) == IS_OBJECT) { ZEPHIR_INIT_VAR(_39$$59); ZVAL_STRING(_39$$59, "router:afterCheckRoutes", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, 0, _39$$59, this_ptr); zephir_check_temp_parameter(_39$$59); zephir_check_call_status(); } ZEPHIR_MM_RESTORE(); }
/** * We have to cast values manually because parse_ini_file() has a poor implementation. * * @param mixed ini The array casted by `parse_ini_file` */ PHP_METHOD(Phalcon_Config_Adapter_Ini, _cast) { zend_bool _5$$5, _6$$5, _8$$5, _9$$5; HashTable *_1$$3; HashPosition _0$$3; zephir_fcall_cache_entry *_4 = NULL; int ZEPHIR_LAST_CALL_STATUS; zval *ini, *key = NULL, *val = NULL, **_2$$3, *_3$$4 = NULL, *_7$$5, *_10$$5, *_11$$9, *_12$$9, _13$$9; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &ini); ZEPHIR_SEPARATE_PARAM(ini); if (Z_TYPE_P(ini) == IS_ARRAY) { zephir_is_iterable(ini, &_1$$3, &_0$$3, 1, 0, "phalcon/config/adapter/ini.zep", 134); for ( ; zephir_hash_get_current_data_ex(_1$$3, (void**) &_2$$3, &_0$$3) == SUCCESS ; zephir_hash_move_forward_ex(_1$$3, &_0$$3) ) { ZEPHIR_GET_HMKEY(key, _1$$3, _0$$3); ZEPHIR_GET_HVALUE(val, _2$$3); ZEPHIR_CALL_METHOD(&_3$$4, this_ptr, "_cast", &_4, 135, val); zephir_check_call_status(); zephir_array_update_zval(&ini, key, &_3$$4, PH_COPY | PH_SEPARATE); } zend_hash_destroy(_1$$3); FREE_HASHTABLE(_1$$3); } if (Z_TYPE_P(ini) == IS_STRING) { _5$$5 = ZEPHIR_IS_STRING_IDENTICAL(ini, "true"); if (!(_5$$5)) { _5$$5 = ZEPHIR_IS_STRING_IDENTICAL(ini, "yes"); } _6$$5 = _5$$5; if (!(_6$$5)) { ZEPHIR_INIT_VAR(_7$$5); zephir_fast_strtolower(_7$$5, ini); _6$$5 = ZEPHIR_IS_STRING_IDENTICAL(_7$$5, "on"); } if (_6$$5) { RETURN_MM_BOOL(1); } _8$$5 = ZEPHIR_IS_STRING_IDENTICAL(ini, "false"); if (!(_8$$5)) { _8$$5 = ZEPHIR_IS_STRING_IDENTICAL(ini, "no"); } _9$$5 = _8$$5; if (!(_9$$5)) { ZEPHIR_INIT_VAR(_10$$5); zephir_fast_strtolower(_10$$5, ini); _9$$5 = ZEPHIR_IS_STRING_IDENTICAL(_10$$5, "off"); } if (_9$$5) { RETURN_MM_BOOL(0); } if (ZEPHIR_IS_STRING_IDENTICAL(ini, "null")) { RETURN_MM_NULL(); } if (zephir_is_numeric(ini)) { ZEPHIR_INIT_VAR(_11$$9); ZEPHIR_INIT_VAR(_12$$9); ZEPHIR_SINIT_VAR(_13$$9); ZVAL_STRING(&_13$$9, "/[.]+/", 0); zephir_preg_match(_12$$9, &_13$$9, ini, _11$$9, 0, 0 , 0 TSRMLS_CC); if (zephir_is_true(_12$$9)) { RETURN_MM_DOUBLE(zephir_get_doubleval(ini)); } else { RETURN_MM_LONG(zephir_get_intval(ini)); } } } RETVAL_ZVAL(ini, 1, 0); RETURN_MM(); }
/** * Transform an intermediate representation for a schema/table into a database system valid expression * * @param array table * @param string escapeChar * @return string */ PHP_METHOD(Pdm_Db_AbstractDialect, getSqlTable) { zval *escapeChar = NULL, *_1 = NULL; zval *table, *escapeChar_param = NULL, *sqlTable = NULL, *sqlSchema = NULL, *aliasName, *sqlTableAlias = NULL, *schemaName, *tableName, *_0; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &table, &escapeChar_param); if (!escapeChar_param) { ZEPHIR_INIT_VAR(escapeChar); ZVAL_EMPTY_STRING(escapeChar); } else { zephir_get_strval(escapeChar, escapeChar_param); } if (ZEPHIR_IS_STRING_IDENTICAL(escapeChar, "")) { ZEPHIR_OBS_VAR(_0); zephir_read_property_this(&_0, this_ptr, SL("escapeChar"), PH_NOISY_CC); zephir_get_strval(_1, _0); ZEPHIR_CPY_WRT(escapeChar, _1); } if (Z_TYPE_P(table) == IS_ARRAY) { ZEPHIR_OBS_VAR(tableName); zephir_array_fetch_long(&tableName, table, 0, PH_NOISY TSRMLS_CC); if (ZEPHIR_GLOBAL(db).escape_identifiers) { ZEPHIR_INIT_VAR(sqlTable); ZEPHIR_CONCAT_VVV(sqlTable, escapeChar, tableName, escapeChar); } else { ZEPHIR_CPY_WRT(sqlTable, tableName); } ZEPHIR_OBS_VAR(schemaName); zephir_array_fetch_long(&schemaName, table, 1, PH_NOISY TSRMLS_CC); if (Z_TYPE_P(schemaName) != IS_ARRAY) { ZEPHIR_INIT_VAR(sqlSchema); if (ZEPHIR_GLOBAL(db).escape_identifiers) { ZEPHIR_CONCAT_VVVSV(sqlSchema, escapeChar, schemaName, escapeChar, ".", sqlTable); } else { ZEPHIR_CONCAT_VSV(sqlSchema, schemaName, ".", sqlTable); } } else { ZEPHIR_CPY_WRT(sqlSchema, sqlTable); } ZEPHIR_OBS_VAR(aliasName); if (zephir_array_isset_long_fetch(&aliasName, table, 2, 0 TSRMLS_CC)) { ZEPHIR_INIT_VAR(sqlTableAlias); if (ZEPHIR_GLOBAL(db).escape_identifiers) { ZEPHIR_CONCAT_VSVVV(sqlTableAlias, sqlSchema, " AS ", escapeChar, aliasName, escapeChar); } else { ZEPHIR_CONCAT_VSV(sqlTableAlias, sqlSchema, " AS ", aliasName); } } else { ZEPHIR_CPY_WRT(sqlTableAlias, sqlSchema); } RETURN_CCTOR(sqlTableAlias); } if (ZEPHIR_GLOBAL(db).escape_identifiers) { ZEPHIR_CONCAT_VVV(return_value, escapeChar, table, escapeChar); RETURN_MM(); } RETURN_CCTOR(table); }
/** * Encrypts a text * *<code> * $encrypted = $crypt->encrypt("Ultra-secret text", "encrypt password"); *</code> */ PHP_METHOD(Phalcon_Crypt, encrypt) { zend_bool _4, _5; zephir_nts_static zephir_fcall_cache_entry *_2 = NULL, *_6 = NULL; int ZEPHIR_LAST_CALL_STATUS, _3; zval *text_param = NULL, *key_param = NULL, *encryptKey = NULL, *ivSize = NULL, *iv = NULL, *cipher, *mode, *blockSize = NULL, *paddingType, *padded = NULL, _0, *_1 = NULL; zval *text = NULL, *key = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &text_param, &key_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 (!key_param) { ZEPHIR_INIT_VAR(key); ZVAL_EMPTY_STRING(key); } else { 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); } } if (!((zephir_function_exists_ex(SS("mcrypt_get_iv_size") TSRMLS_CC) == SUCCESS))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "mcrypt extension is required", "phalcon/crypt.zep", 306); return; } if (ZEPHIR_IS_STRING_IDENTICAL(key, "")) { ZEPHIR_OBS_VAR(encryptKey); zephir_read_property_this(&encryptKey, this_ptr, SL("_key"), PH_NOISY_CC); } else { ZEPHIR_CPY_WRT(encryptKey, key); } if (ZEPHIR_IS_EMPTY(encryptKey)) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Encryption key cannot be empty", "phalcon/crypt.zep", 316); return; } ZEPHIR_OBS_VAR(cipher); zephir_read_property_this(&cipher, this_ptr, SL("_cipher"), PH_NOISY_CC); ZEPHIR_OBS_VAR(mode); zephir_read_property_this(&mode, this_ptr, SL("_mode"), PH_NOISY_CC); ZEPHIR_CALL_FUNCTION(&ivSize, "mcrypt_get_iv_size", NULL, cipher, mode); zephir_check_call_status(); if (ZEPHIR_LT_LONG(ivSize, zephir_fast_strlen_ev(encryptKey))) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_crypt_exception_ce, "Size of key is too large for this algorithm", "phalcon/crypt.zep", 324); return; } ZEPHIR_SINIT_VAR(_0); ZVAL_LONG(&_0, 2); ZEPHIR_CALL_FUNCTION(&iv, "mcrypt_create_iv", NULL, ivSize, &_0); zephir_check_call_status(); if (Z_TYPE_P(iv) != IS_STRING) { ZEPHIR_CALL_FUNCTION(&_1, "strval", &_2, iv); zephir_check_call_status(); ZEPHIR_CPY_WRT(iv, _1); } ZEPHIR_CALL_FUNCTION(&blockSize, "mcrypt_get_block_size", NULL, cipher, mode); zephir_check_call_status(); if (Z_TYPE_P(blockSize) != IS_LONG) { _3 = zephir_get_intval(blockSize); ZEPHIR_INIT_NVAR(blockSize); ZVAL_LONG(blockSize, _3); } ZEPHIR_OBS_VAR(paddingType); zephir_read_property_this(&paddingType, this_ptr, SL("_padding"), PH_NOISY_CC); _4 = !ZEPHIR_IS_LONG(paddingType, 0); if (_4) { _5 = ZEPHIR_IS_STRING(mode, "cbc"); if (!(_5)) { _5 = ZEPHIR_IS_STRING(mode, "ecb"); } _4 = _5; } if (_4) { ZEPHIR_CALL_METHOD(&padded, this_ptr, "_cryptpadtext", &_6, text, mode, blockSize, paddingType); zephir_check_call_status(); } else { ZEPHIR_CPY_WRT(padded, text); } ZEPHIR_CALL_FUNCTION(&_1, "mcrypt_encrypt", NULL, cipher, encryptKey, padded, mode, iv); zephir_check_call_status(); ZEPHIR_CONCAT_VV(return_value, iv, _1); RETURN_MM(); }
/** * Builds a Phalcon\Mvc\Model\Criteria based on an input array like _POST */ PHP_METHOD(Phalcon_Mvc_Model_Criteria, fromInput) { zend_bool _6$$4, _7$$7; HashTable *_4$$3; HashPosition _3$$3; zend_class_entry *_2$$3; int ZEPHIR_LAST_CALL_STATUS; zval *data = NULL; zval *modelName = NULL, *operator = NULL, *_12$$10; zval *dependencyInjector, *modelName_param = NULL, *data_param = NULL, *operator_param = NULL, *attribute = NULL, *conditions = NULL, *field = NULL, *value = NULL, *type = NULL, *metaData = NULL, *model = NULL, *dataTypes = NULL, *bind = NULL, *criteria = NULL, *columnMap = NULL, *_0$$3, *_1$$3 = NULL, **_5$$3, *_8$$9 = NULL, *_9$$9 = NULL, *_10$$8 = NULL, *_11$$10; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 3, 1, &dependencyInjector, &modelName_param, &data_param, &operator_param); if (unlikely(Z_TYPE_P(modelName_param) != IS_STRING && Z_TYPE_P(modelName_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'modelName' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(modelName_param) == IS_STRING)) { zephir_get_strval(modelName, modelName_param); } else { ZEPHIR_INIT_VAR(modelName); ZVAL_EMPTY_STRING(modelName); } data = data_param; if (!operator_param) { ZEPHIR_INIT_VAR(operator); ZVAL_STRING(operator, "AND", 1); } else { if (unlikely(Z_TYPE_P(operator_param) != IS_STRING && Z_TYPE_P(operator_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'operator' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(operator_param) == IS_STRING)) { zephir_get_strval(operator, operator_param); } else { ZEPHIR_INIT_VAR(operator); ZVAL_EMPTY_STRING(operator); } } ZEPHIR_INIT_VAR(conditions); array_init(conditions); if (zephir_fast_count_int(data TSRMLS_CC)) { ZEPHIR_INIT_VAR(_0$$3); ZVAL_STRING(_0$$3, "modelsMetadata", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&metaData, dependencyInjector, "getshared", NULL, 0, _0$$3); zephir_check_temp_parameter(_0$$3); zephir_check_call_status(); ZEPHIR_INIT_VAR(model); zephir_fetch_safe_class(_1$$3, modelName); _2$$3 = zend_fetch_class(Z_STRVAL_P(_1$$3), Z_STRLEN_P(_1$$3), ZEND_FETCH_CLASS_AUTO TSRMLS_CC); object_init_ex(model, _2$$3); if (zephir_has_constructor(model TSRMLS_CC)) { ZEPHIR_CALL_METHOD(NULL, model, "__construct", NULL, 0); zephir_check_call_status(); } ZEPHIR_CALL_METHOD(&dataTypes, metaData, "getdatatypes", NULL, 0, model); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&columnMap, metaData, "getreversecolumnmap", NULL, 0, model); zephir_check_call_status(); ZEPHIR_INIT_VAR(bind); array_init(bind); zephir_is_iterable(data, &_4$$3, &_3$$3, 0, 0, "phalcon/mvc/model/criteria.zep", 747); for ( ; zephir_hash_get_current_data_ex(_4$$3, (void**) &_5$$3, &_3$$3) == SUCCESS ; zephir_hash_move_forward_ex(_4$$3, &_3$$3) ) { ZEPHIR_GET_HMKEY(field, _4$$3, _3$$3); ZEPHIR_GET_HVALUE(value, _5$$3); _6$$4 = Z_TYPE_P(columnMap) == IS_ARRAY; if (_6$$4) { _6$$4 = (zephir_fast_count_int(columnMap TSRMLS_CC)) ? 1 : 0; } if (_6$$4) { ZEPHIR_OBS_NVAR(attribute); zephir_array_fetch(&attribute, columnMap, field, PH_NOISY, "phalcon/mvc/model/criteria.zep", 724 TSRMLS_CC); } else { ZEPHIR_CPY_WRT(attribute, field); } ZEPHIR_OBS_NVAR(type); if (zephir_array_isset_fetch(&type, dataTypes, attribute, 0 TSRMLS_CC)) { _7$$7 = Z_TYPE_P(value) != IS_NULL; if (_7$$7) { _7$$7 = !ZEPHIR_IS_STRING_IDENTICAL(value, ""); } if (_7$$7) { if (ZEPHIR_IS_LONG(type, 2)) { ZEPHIR_INIT_LNVAR(_8$$9); ZEPHIR_CONCAT_SVSVS(_8$$9, "[", field, "] LIKE :", field, ":"); zephir_array_append(&conditions, _8$$9, PH_SEPARATE, "phalcon/mvc/model/criteria.zep", 736); ZEPHIR_INIT_LNVAR(_9$$9); ZEPHIR_CONCAT_SVS(_9$$9, "%", value, "%"); zephir_array_update_zval(&bind, field, &_9$$9, PH_COPY | PH_SEPARATE); continue; } ZEPHIR_INIT_LNVAR(_10$$8); ZEPHIR_CONCAT_SVSVS(_10$$8, "[", field, "] = :", field, ":"); zephir_array_append(&conditions, _10$$8, PH_SEPARATE, "phalcon/mvc/model/criteria.zep", 743); zephir_array_update_zval(&bind, field, &value, PH_COPY | PH_SEPARATE); } } } } ZEPHIR_INIT_VAR(criteria); object_init_ex(criteria, phalcon_mvc_model_criteria_ce); if (zephir_has_constructor(criteria TSRMLS_CC)) { ZEPHIR_CALL_METHOD(NULL, criteria, "__construct", NULL, 0); zephir_check_call_status(); } if (zephir_fast_count_int(conditions TSRMLS_CC)) { ZEPHIR_INIT_VAR(_11$$10); ZEPHIR_INIT_VAR(_12$$10); ZEPHIR_CONCAT_SVS(_12$$10, " ", operator, " "); zephir_fast_join(_11$$10, _12$$10, conditions TSRMLS_CC); ZEPHIR_CALL_METHOD(NULL, criteria, "where", NULL, 306, _11$$10); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, criteria, "bind", NULL, 307, bind); zephir_check_call_status(); } ZEPHIR_CALL_METHOD(NULL, criteria, "setmodelname", NULL, 300, modelName); zephir_check_call_status(); RETURN_CCTOR(criteria); }
/** * @todo this method can be write differently with (P< style match * Matches a user submitted path with parts defined by a map. Assigns and * returns an array of variables on a successful match. * * @param string $path Path used to match against this routing map * @return array|false An array of assigned values or a false on a mismatch */ PHP_METHOD(Yaf_Route_Rewrite, _match) { zephir_nts_static zephir_fcall_cache_entry *_27 = NULL, *_33 = NULL; zend_bool _12, _28, _32; HashTable *_7, *_22, *_35; HashPosition _6, _21, _34; int staticCount, pathStaticCount, ZEPHIR_LAST_CALL_STATUS; zval *path_param = NULL, *values, *matchedPath = NULL, *parts, *variables, *wildcardData, *name = NULL, *part = NULL, *pos = NULL, *pathMatch, *count = NULL, *i = NULL, *varr = NULL, *pathPart = NULL, *tmpReturn = NULL, *_0, *_1 = NULL, *_2 = NULL, *_3, _4 = zval_used_for_init, _5 = zval_used_for_init, **_8, _9 = zval_used_for_init, _10 = zval_used_for_init, *_11 = NULL, _13 = zval_used_for_init, _14 = zval_used_for_init, *_15 = NULL, _16 = zval_used_for_init, _17 = zval_used_for_init, *_18 = NULL, _19 = zval_used_for_init, *_20 = NULL, **_23, *_24 = NULL, *_25, *_26, *_29 = NULL, *_30, *_31 = NULL, **_36; zval *path = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &path_param); zephir_get_strval(path, path_param); staticCount = 0; pathStaticCount = 0; ZEPHIR_INIT_VAR(values); array_init(values); ZEPHIR_INIT_VAR(matchedPath); ZVAL_STRING(matchedPath, "", 1); ZEPHIR_INIT_VAR(parts); array_init(parts); ZEPHIR_INIT_VAR(variables); array_init(variables); ZEPHIR_INIT_VAR(wildcardData); array_init(wildcardData); _0 = zephir_fetch_nproperty_this(this_ptr, SL("_route"), PH_NOISY_CC); if (!ZEPHIR_IS_STRING_IDENTICAL(_0, "")) { ZEPHIR_INIT_VAR(_1); ZEPHIR_INIT_VAR(_2); _3 = zephir_fetch_nproperty_this(this_ptr, SL("_route"), PH_NOISY_CC); ZEPHIR_SINIT_VAR(_4); ZVAL_STRING(&_4, "/", 0); zephir_fast_trim(_2, _3, &_4, ZEPHIR_TRIM_BOTH TSRMLS_CC); ZEPHIR_SINIT_VAR(_5); ZVAL_STRING(&_5, "/", 0); zephir_fast_explode(_1, &_5, _2, LONG_MAX TSRMLS_CC); zephir_is_iterable(_1, &_7, &_6, 0, 0, "yaf/Route/rewrite.zep", 135); for ( ; zephir_hash_get_current_data_ex(_7, (void**) &_8, &_6) == SUCCESS ; zephir_hash_move_forward_ex(_7, &_6) ) { ZEPHIR_GET_HMKEY(pos, _7, _6); ZEPHIR_GET_HVALUE(part, _8); ZEPHIR_SINIT_NVAR(_9); ZVAL_LONG(&_9, 0); ZEPHIR_SINIT_NVAR(_10); ZVAL_LONG(&_10, 1); ZEPHIR_INIT_NVAR(_11); zephir_substr(_11, part, 0 , 1 , 0); _12 = ZEPHIR_IS_STRING(_11, ":"); if (_12) { ZEPHIR_SINIT_NVAR(_13); ZVAL_LONG(&_13, 1); ZEPHIR_SINIT_NVAR(_14); ZVAL_LONG(&_14, 1); ZEPHIR_INIT_NVAR(_15); zephir_substr(_15, part, 1 , 1 , 0); _12 = !ZEPHIR_IS_STRING(_15, ":"); } if (_12) { ZEPHIR_SINIT_NVAR(_16); ZVAL_LONG(&_16, 1); ZEPHIR_INIT_NVAR(name); zephir_substr(name, part, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH); zephir_array_update_zval(&parts, pos, &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE); zephir_array_update_zval(&variables, pos, &name, PH_COPY | PH_SEPARATE); } else { ZEPHIR_SINIT_NVAR(_16); ZVAL_LONG(&_16, 0); ZEPHIR_SINIT_NVAR(_17); ZVAL_LONG(&_17, 1); ZEPHIR_INIT_NVAR(_18); zephir_substr(_18, part, 0 , 1 , 0); if (ZEPHIR_IS_STRING(_18, ":")) { ZEPHIR_SINIT_NVAR(_19); ZVAL_LONG(&_19, 1); ZEPHIR_INIT_NVAR(_20); zephir_substr(_20, part, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH); ZEPHIR_CPY_WRT(part, _20); } zephir_array_update_zval(&parts, pos, &part, PH_COPY | PH_SEPARATE); if (!ZEPHIR_IS_STRING_IDENTICAL(part, "*")) { staticCount++; } } } } if (!ZEPHIR_IS_STRING_IDENTICAL(path, "")) { ZEPHIR_INIT_VAR(pathMatch); ZEPHIR_SINIT_NVAR(_4); ZVAL_STRING(&_4, "/", 0); zephir_fast_explode(pathMatch, &_4, path, LONG_MAX TSRMLS_CC); zephir_is_iterable(pathMatch, &_22, &_21, 0, 0, "yaf/Route/rewrite.zep", 193); for ( ; zephir_hash_get_current_data_ex(_22, (void**) &_23, &_21) == SUCCESS ; zephir_hash_move_forward_ex(_22, &_21) ) { ZEPHIR_GET_HMKEY(pos, _22, _21); ZEPHIR_GET_HVALUE(pathPart, _23); if (!(zephir_array_key_exists(parts, pos TSRMLS_CC))) { RETURN_MM_BOOL(0); } ZEPHIR_INIT_LNVAR(_24); ZEPHIR_CONCAT_VS(_24, pathPart, "/"); zephir_concat_self(&matchedPath, _24 TSRMLS_CC); zephir_array_fetch(&_25, parts, pos, PH_NOISY | PH_READONLY, "yaf/Route/rewrite.zep", 150 TSRMLS_CC); if (ZEPHIR_IS_STRING(_25, "*")) { ZEPHIR_INIT_NVAR(count); ZVAL_LONG(count, zephir_fast_count_int(pathMatch TSRMLS_CC)); ZEPHIR_CPY_WRT(i, pos); while (1) { if (!(ZEPHIR_LT(i, count))) { break; } zephir_array_fetch(&_26, pathMatch, i, PH_NOISY | PH_READONLY, "yaf/Route/rewrite.zep", 154 TSRMLS_CC); ZEPHIR_CALL_FUNCTION(&varr, "urldecode", &_27, _26); zephir_check_call_status(); _12 = !(zephir_array_isset(wildcardData, varr)); if (_12) { _3 = zephir_fetch_nproperty_this(this_ptr, SL("_default"), PH_NOISY_CC); _12 = !(zephir_array_isset(_3, varr)); } _28 = _12; if (_28) { _28 = !(zephir_array_isset(values, varr)); } if (_28) { ZEPHIR_INIT_LNVAR(_29); if (zephir_array_isset_long(pathMatch, (zephir_get_numberval(i) + 1))) { zephir_array_fetch_long(&_30, pathMatch, (zephir_get_numberval(i) + 1), PH_NOISY | PH_READONLY, "yaf/Route/rewrite.zep", 157 TSRMLS_CC); ZEPHIR_CALL_FUNCTION(&_29, "urldecode", &_27, _30); zephir_check_call_status(); } else { ZEPHIR_INIT_NVAR(_29); ZVAL_NULL(_29); } zephir_array_update_zval(&wildcardData, varr, &_29, PH_COPY | PH_SEPARATE); } ZEPHIR_INIT_NVAR(_1); ZVAL_LONG(_1, 2); ZEPHIR_ADD_ASSIGN(i, _1); } ZEPHIR_INIT_NVAR(matchedPath); ZEPHIR_SINIT_NVAR(_5); ZVAL_STRING(&_5, "/", 0); zephir_fast_join(matchedPath, &_5, pathMatch TSRMLS_CC); break; } if (zephir_array_isset(variables, pos)) { ZEPHIR_OBS_NVAR(name); zephir_array_fetch(&name, variables, pos, PH_NOISY, "yaf/Route/rewrite.zep", 165 TSRMLS_CC); } else { ZEPHIR_INIT_NVAR(name); ZVAL_NULL(name); } ZEPHIR_CALL_FUNCTION(&_31, "urldecode", &_27, pathPart); zephir_check_call_status(); ZEPHIR_CPY_WRT(pathPart, _31); ZEPHIR_OBS_NVAR(part); zephir_array_fetch(&part, parts, pos, PH_NOISY, "yaf/Route/rewrite.zep", 167 TSRMLS_CC); ZEPHIR_SINIT_NVAR(_9); ZVAL_LONG(&_9, 0); ZEPHIR_SINIT_NVAR(_10); ZVAL_LONG(&_10, 2); ZEPHIR_INIT_NVAR(_2); zephir_substr(_2, part, 0 , 2 , 0); if (ZEPHIR_IS_STRING_IDENTICAL(_2, "@@")) { ZEPHIR_SINIT_NVAR(_13); ZVAL_LONG(&_13, 1); ZEPHIR_INIT_NVAR(_11); zephir_substr(_11, part, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH); ZEPHIR_CPY_WRT(part, _11); } _28 = Z_TYPE_P(name) == IS_NULL; if (_28) { _28 = !ZEPHIR_IS_EQUAL(part, pathPart); } if (_28) { RETURN_MM_BOOL(0); } _32 = Z_TYPE_P(part) != IS_NULL; if (_32) { ZEPHIR_INIT_LNVAR(_29); ZEPHIR_CONCAT_VSSS(_29, part, "#^", "$#", "iu"); ZEPHIR_CALL_FUNCTION(&_31, "preg_match", &_33, _29, pathPart); zephir_check_call_status(); _32 = !zephir_is_true(_31); } if (_32) { RETURN_MM_BOOL(0); } if (Z_TYPE_P(name) != IS_NULL) { zephir_array_update_zval(&values, name, &pathPart, PH_COPY | PH_SEPARATE); } else { pathStaticCount++; } } } if (staticCount != pathStaticCount) { RETURN_MM_BOOL(0); } ZEPHIR_INIT_VAR(tmpReturn); zephir_add_function_ex(tmpReturn, values, wildcardData TSRMLS_CC); zephir_is_iterable(variables, &_35, &_34, 0, 0, "yaf/Route/rewrite.zep", 212); for ( ; zephir_hash_get_current_data_ex(_35, (void**) &_36, &_34) == SUCCESS ; zephir_hash_move_forward_ex(_35, &_34) ) { ZEPHIR_GET_HVALUE(varr, _36); if (!(zephir_array_key_exists(tmpReturn, varr TSRMLS_CC))) { RETURN_MM_BOOL(0); } } _12 = Z_TYPE_P(values) == IS_NULL; if (_12) { _12 = Z_TYPE_P(wildcardData) == IS_NULL; } _32 = _12; if (_32) { _32 = staticCount != 0; } if (_32) { _3 = zephir_fetch_nproperty_this(this_ptr, SL("_default"), PH_NOISY_CC); ZEPHIR_INIT_LNVAR(_24); zephir_add_function_ex(_24, tmpReturn, _3 TSRMLS_CC); ZEPHIR_CPY_WRT(tmpReturn, _24); } RETURN_CCTOR(tmpReturn); }
/** * Executes the validation */ PHP_METHOD(Phalcon_Validation_Validator_PresenceOf, validate) { zend_bool _0; int ZEPHIR_LAST_CALL_STATUS; zval *field = NULL; zval *validation, *field_param = NULL, *value = NULL, *message = NULL, *label = NULL, *replacePairs, *_1 = NULL, *_2 = NULL, *_3; 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(); _0 = Z_TYPE_P(value) == IS_NULL; if (!(_0)) { _0 = ZEPHIR_IS_STRING_IDENTICAL(value, ""); } if (_0) { ZEPHIR_INIT_VAR(_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, "PresenceOf", 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(&_2, "strtr", NULL, 53, message, replacePairs); zephir_check_call_status(); ZEPHIR_INIT_VAR(_3); ZVAL_STRING(_3, "PresenceOf", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, 436, _2, field, _3); zephir_check_temp_parameter(_3); 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); }
/** * Reads a packet from the socket. Prior to reading from the socket will * check for availability of the connection. */ PHP_METHOD(Phalcon_Queue_Beanstalk, read) { zephir_fcall_cache_entry *_2 = NULL; zval *length_param = NULL, *connection = NULL, *data = NULL, _0$$5 = zval_used_for_init, *_1$$5 = NULL, *_3$$5 = NULL, *_4$$5, _5$$8, _6$$8; int length, ZEPHIR_LAST_CALL_STATUS; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &length_param); if (!length_param) { length = 0; } else { length = zephir_get_intval(length_param); } ZEPHIR_OBS_VAR(connection); zephir_read_property_this(&connection, this_ptr, SL("_connection"), PH_NOISY_CC); if (Z_TYPE_P(connection) != IS_RESOURCE) { ZEPHIR_CALL_METHOD(&connection, this_ptr, "connect", NULL, 0); zephir_check_call_status(); if (Z_TYPE_P(connection) != IS_RESOURCE) { RETURN_MM_BOOL(0); } } if (length) { if (zephir_feof(connection TSRMLS_CC)) { RETURN_MM_BOOL(0); } ZEPHIR_SINIT_VAR(_0$$5); ZVAL_LONG(&_0$$5, (length + 2)); ZEPHIR_CALL_FUNCTION(&_1$$5, "stream_get_line", &_2, 413, connection, &_0$$5); zephir_check_call_status(); ZEPHIR_SINIT_NVAR(_0$$5); ZVAL_STRING(&_0$$5, "\r\n", 0); ZEPHIR_INIT_VAR(data); zephir_fast_trim(data, _1$$5, &_0$$5, ZEPHIR_TRIM_RIGHT TSRMLS_CC); ZEPHIR_CALL_FUNCTION(&_3$$5, "stream_get_meta_data", NULL, 414, connection); zephir_check_call_status(); zephir_array_fetch_string(&_4$$5, _3$$5, SL("timed_out"), PH_NOISY | PH_READONLY, "phalcon/queue/beanstalk.zep", 535 TSRMLS_CC); if (zephir_is_true(_4$$5)) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_queue_beanstalk_exception_ce, "Connection timed out", "phalcon/queue/beanstalk.zep", 536); return; } } else { ZEPHIR_SINIT_VAR(_5$$8); ZVAL_LONG(&_5$$8, 16384); ZEPHIR_SINIT_VAR(_6$$8); ZVAL_STRING(&_6$$8, "\r\n", 0); ZEPHIR_CALL_FUNCTION(&data, "stream_get_line", &_2, 413, connection, &_5$$8, &_6$$8); zephir_check_call_status(); } if (ZEPHIR_IS_STRING_IDENTICAL(data, "UNKNOWN_COMMAND")) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_queue_beanstalk_exception_ce, "UNKNOWN_COMMAND", "phalcon/queue/beanstalk.zep", 544); return; } if (ZEPHIR_IS_STRING_IDENTICAL(data, "JOB_TOO_BIG")) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_queue_beanstalk_exception_ce, "JOB_TOO_BIG", "phalcon/queue/beanstalk.zep", 548); return; } if (ZEPHIR_IS_STRING_IDENTICAL(data, "BAD_FORMAT")) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_queue_beanstalk_exception_ce, "BAD_FORMAT", "phalcon/queue/beanstalk.zep", 552); return; } if (ZEPHIR_IS_STRING_IDENTICAL(data, "OUT_OF_MEMORY")) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_queue_beanstalk_exception_ce, "OUT_OF_MEMORY", "phalcon/queue/beanstalk.zep", 556); return; } RETURN_CCTOR(data); }
/** * Executes the validation */ PHP_METHOD(Phalcon_Validation_Validator_PresenceOf, validate) { zend_bool _0; int ZEPHIR_LAST_CALL_STATUS; zval *field = NULL; zval *validation, *field_param = NULL, *value = NULL, *message = NULL, *label = NULL, *replacePairs = NULL, *code = 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(); _0 = Z_TYPE_P(value) == IS_NULL; if (!(_0)) { _0 = ZEPHIR_IS_STRING_IDENTICAL(value, ""); } if (_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/presenceof.zep", 74 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/presenceof.zep", 82 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, "PresenceOf", 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/presenceof.zep", 91 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, "PresenceOf", 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); }
/** * Set the background color of an image */ PHP_METHOD(Phalcon_Image_Adapter, background) { zend_bool _0; int opacity, ZEPHIR_LAST_CALL_STATUS; zval *color_param = NULL, *opacity_param = NULL, *colors = NULL, _1, _2, *_3, _4 = zval_used_for_init, *_5 = NULL, *_6, *_7 = NULL, *_8, *_9, *_10; zval *color = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &color_param, &opacity_param); zephir_get_strval(color, color_param); if (!opacity_param) { opacity = 100; } else { opacity = zephir_get_intval(opacity_param); } _0 = zephir_fast_strlen_ev(color) > 1; if (_0) { ZEPHIR_SINIT_VAR(_1); ZVAL_LONG(&_1, 0); ZEPHIR_SINIT_VAR(_2); ZVAL_LONG(&_2, 1); ZEPHIR_INIT_VAR(_3); zephir_substr(_3, color, 0 , 1 , 0); _0 = ZEPHIR_IS_STRING_IDENTICAL(_3, "#"); } if (_0) { ZEPHIR_SINIT_VAR(_4); ZVAL_LONG(&_4, 1); ZEPHIR_INIT_VAR(_5); zephir_substr(_5, color, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH); zephir_get_strval(color, _5); } if (zephir_fast_strlen_ev(color) == 3) { ZEPHIR_INIT_NVAR(_5); ZVAL_STRING(_5, "/./", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_VAR(_6); ZVAL_STRING(_6, "$0$0", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_FUNCTION(&_7, "preg_replace", NULL, 29, _5, _6, color); zephir_check_temp_parameter(_5); zephir_check_temp_parameter(_6); zephir_check_call_status(); zephir_get_strval(color, _7); } ZEPHIR_SINIT_NVAR(_4); ZVAL_LONG(&_4, 2); ZEPHIR_CALL_FUNCTION(&_7, "str_split", NULL, 69, color, &_4); zephir_check_call_status(); ZEPHIR_SINIT_NVAR(_4); ZVAL_STRING(&_4, "hexdec", 0); ZEPHIR_CALL_FUNCTION(&colors, "array_map", NULL, 70, &_4, _7); zephir_check_call_status(); zephir_array_fetch_long(&_8, colors, 0, PH_NOISY | PH_READONLY, "phalcon/image/adapter.zep", 366 TSRMLS_CC); zephir_array_fetch_long(&_9, colors, 1, PH_NOISY | PH_READONLY, "phalcon/image/adapter.zep", 366 TSRMLS_CC); zephir_array_fetch_long(&_10, colors, 2, PH_NOISY | PH_READONLY, "phalcon/image/adapter.zep", 366 TSRMLS_CC); ZEPHIR_INIT_NVAR(_5); ZVAL_LONG(_5, opacity); ZEPHIR_CALL_METHOD(NULL, this_ptr, "_background", NULL, 0, _8, _9, _10, _5); zephir_check_call_status(); RETURN_THIS(); }