PHP_METHOD(ADOdb_Cache, getQueryId) {
zval *sql_param = NULL, *params = NULL, *_0 = NULL, *_1, *_2;
zval *sql = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &sql_param, ¶ms);
zephir_get_strval(sql, sql_param);
if (!params) {
params = ZEPHIR_GLOBAL(global_null);
}
if ((Z_TYPE_P(params) != IS_NULL)) {
ZEPHIR_INIT_VAR(_0);
zephir_fast_join_str(_0, SL(""), params TSRMLS_CC);
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_VV(_1, sql, _0);
ZEPHIR_INIT_VAR(_2);
zephir_call_func_p1(_2, "md5", _1);
ZEPHIR_CONCAT_SV(return_value, "DB_", _2);
RETURN_MM();
} else {
ZEPHIR_INIT_NVAR(_0);
zephir_call_func_p1(_0, "md5", sql);
ZEPHIR_CONCAT_SV(return_value, "DB_", _0);
RETURN_MM();
}
ZEPHIR_MM_RESTORE();
}
/**
* Generates SQL to drop a view
*
* @param string viewName
* @param string schemaName
* @param boolean ifExists
* @return string
*/
PHP_METHOD(Phalcon_Db_Dialect_Postgresql, dropView) {
zval *viewName, *schemaName, *ifExists = NULL, *view = NULL, *sql;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 1, &viewName, &schemaName, &ifExists);
if (!ifExists) {
ifExists = ZEPHIR_GLOBAL(global_true);
}
if (zephir_is_true(schemaName)) {
ZEPHIR_INIT_VAR(view);
ZEPHIR_CONCAT_VSV(view, viewName, ".", schemaName);
} else {
ZEPHIR_CPY_WRT(view, viewName);
}
ZEPHIR_INIT_VAR(sql);
if (zephir_is_true(ifExists)) {
ZEPHIR_CONCAT_SV(sql, "DROP VIEW IF EXISTS ", view);
} else {
ZEPHIR_CONCAT_SV(sql, "DROP VIEW ", view);
}
RETURN_CCTOR(sql);
}
/**
* Sets locale information
*
* <code>
* // Set locale to Dutch
* $gettext->setLocale(LC_ALL, "nl_NL");
*
* // Try different possible locale names for german
* $gettext->setLocale(LC_ALL, "de_DE@euro", "de_DE", "de", "ge");
* </code>
*/
PHP_METHOD(Phalcon_Translate_Adapter_Gettext, setLocale) {
zval *locale = NULL;
zval *category_param = NULL, *locale_param = NULL, *_0, *_1, _2, *_3, *_4, *_5, *_6, *_7, *_8, *_9, _10;
zend_long category, ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &category_param, &locale_param);
if (UNEXPECTED(Z_TYPE_P(category_param) != IS_LONG)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'category' must be a int") TSRMLS_CC);
RETURN_MM_NULL();
}
category = Z_LVAL_P(category_param);
if (UNEXPECTED(Z_TYPE_P(locale_param) != IS_STRING && Z_TYPE_P(locale_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'locale' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(locale_param) == IS_STRING)) {
zephir_get_strval(locale, locale_param);
} else {
ZEPHIR_INIT_VAR(locale);
ZVAL_EMPTY_STRING(locale);
}
ZEPHIR_INIT_VAR(_0);
ZEPHIR_INIT_VAR(_1);
zephir_get_args(_1 TSRMLS_CC);
ZEPHIR_SINIT_VAR(_2);
ZVAL_STRING(&_2, "setlocale", 0);
ZEPHIR_CALL_USER_FUNC_ARRAY(_0, &_2, _1);
zephir_check_call_status();
zephir_update_property_this(getThis(), SL("_locale"), _0 TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_3);
ZVAL_LONG(_3, category);
zephir_update_property_this(getThis(), SL("_category"), _3 TSRMLS_CC);
_3 = zephir_fetch_nproperty_this(this_ptr, SL("_locale"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_4);
ZEPHIR_CONCAT_SV(_4, "LC_ALL=", _3);
ZEPHIR_CALL_FUNCTION(NULL, "putenv", NULL, 474, _4);
zephir_check_call_status();
_5 = zephir_fetch_nproperty_this(this_ptr, SL("_locale"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_6);
ZEPHIR_CONCAT_SV(_6, "LANG=", _5);
ZEPHIR_CALL_FUNCTION(NULL, "putenv", NULL, 474, _6);
zephir_check_call_status();
_7 = zephir_fetch_nproperty_this(this_ptr, SL("_locale"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_8);
ZEPHIR_CONCAT_SV(_8, "LANGUAGE=", _7);
ZEPHIR_CALL_FUNCTION(NULL, "putenv", NULL, 474, _8);
zephir_check_call_status();
_9 = zephir_fetch_nproperty_this(this_ptr, SL("_locale"), PH_NOISY_CC);
ZEPHIR_SINIT_VAR(_10);
ZVAL_LONG(&_10, 6);
ZEPHIR_CALL_FUNCTION(NULL, "setlocale", NULL, 456, &_10, _9);
zephir_check_call_status();
RETURN_MM_MEMBER(getThis(), "_locale");
}
/**
* Generates SQL to drop a table
*
* @param string tableName
* @param string schemaName
* @param boolean ifExists
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Dialect_Postgresql, dropTable) {
zval *tableName, *schemaName, *ifExists = NULL, *table = NULL, *sql;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 1, &tableName, &schemaName, &ifExists);
if (!ifExists) {
ifExists = ZEPHIR_GLOBAL(global_true);
}
if (zephir_is_true(schemaName)) {
ZEPHIR_INIT_VAR(table);
ZEPHIR_CONCAT_VSV(table, schemaName, ".", tableName);
} else {
ZEPHIR_CPY_WRT(table, tableName);
}
ZEPHIR_INIT_VAR(sql);
if (zephir_is_true(ifExists)) {
ZEPHIR_CONCAT_SV(sql, "DROP TABLE IF EXISTS ", table);
} else {
ZEPHIR_CONCAT_SV(sql, "DROP TABLE ", table);
}
RETURN_CCTOR(sql);
}
PHP_METHOD(Yb_Std, uniqueValues) {
HashTable *_1;
HashPosition _0;
zephir_fcall_cache_entry *_5 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *uniqueKey = NULL;
zval *data_param = NULL, *uniqueKey_param = NULL, *k = NULL, *v = NULL, *arr = NULL, *uniqueValue = NULL, **_2, *_3$$4 = NULL, *_4$$4 = NULL, *_6$$5 = NULL, *_7$$5 = NULL;
zval *data = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &data_param, &uniqueKey_param);
zephir_get_arrval(data, data_param);
zephir_get_strval(uniqueKey, uniqueKey_param);
ZEPHIR_INIT_VAR(arr);
array_init(arr);
zephir_is_iterable(data, &_1, &_0, 0, 0, "yb/std.zep", 377);
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);
if (unlikely(Z_TYPE_P(v) != IS_ARRAY)) {
ZEPHIR_INIT_NVAR(_3$$4);
object_init_ex(_3$$4, yb_exception_ce);
ZEPHIR_INIT_LNVAR(_4$$4);
ZEPHIR_CONCAT_SV(_4$$4, "Invalid item type, array required at: ", k);
ZEPHIR_CALL_METHOD(NULL, _3$$4, "__construct", &_5, 2, _4$$4);
zephir_check_call_status();
zephir_throw_exception_debug(_3$$4, "yb/std.zep", 368 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_OBS_NVAR(uniqueValue);
if (unlikely(!(zephir_array_isset_fetch(&uniqueValue, v, uniqueKey, 0 TSRMLS_CC)))) {
ZEPHIR_INIT_NVAR(_6$$5);
object_init_ex(_6$$5, yb_exception_ce);
ZEPHIR_INIT_LNVAR(_7$$5);
ZEPHIR_CONCAT_SV(_7$$5, "Cannot find value of unique at: ", k);
ZEPHIR_CALL_METHOD(NULL, _6$$5, "__construct", &_5, 2, _7$$5);
zephir_check_call_status();
zephir_throw_exception_debug(_6$$5, "yb/std.zep", 371 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
zephir_array_update_zval(&arr, uniqueValue, &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
}
zephir_array_keys(return_value, arr TSRMLS_CC);
RETURN_MM();
}
PHP_METHOD(Yb_Std, groupedData) {
HashTable *_1;
HashPosition _0;
zephir_fcall_cache_entry *_5 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *groupKey = NULL;
zval *data_param = NULL, *groupKey_param = NULL, *k = NULL, *v = NULL, *arr = NULL, *groupValue = NULL, **_2, *_3$$4 = NULL, *_4$$4 = NULL, *_6$$5 = NULL, *_7$$5 = NULL;
zval *data = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &data_param, &groupKey_param);
zephir_get_arrval(data, data_param);
zephir_get_strval(groupKey, groupKey_param);
ZEPHIR_INIT_VAR(arr);
array_init(arr);
zephir_is_iterable(data, &_1, &_0, 0, 0, "yb/std.zep", 293);
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);
if (unlikely(Z_TYPE_P(v) != IS_ARRAY)) {
ZEPHIR_INIT_NVAR(_3$$4);
object_init_ex(_3$$4, yb_exception_ce);
ZEPHIR_INIT_LNVAR(_4$$4);
ZEPHIR_CONCAT_SV(_4$$4, "Invalid item type, array required at: ", k);
ZEPHIR_CALL_METHOD(NULL, _3$$4, "__construct", &_5, 2, _4$$4);
zephir_check_call_status();
zephir_throw_exception_debug(_3$$4, "yb/std.zep", 284 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_OBS_NVAR(groupValue);
if (unlikely(!(zephir_array_isset_fetch(&groupValue, v, groupKey, 0 TSRMLS_CC)))) {
ZEPHIR_INIT_NVAR(_6$$5);
object_init_ex(_6$$5, yb_exception_ce);
ZEPHIR_INIT_LNVAR(_7$$5);
ZEPHIR_CONCAT_SV(_7$$5, "Cannot find value of group at: ", k);
ZEPHIR_CALL_METHOD(NULL, _6$$5, "__construct", &_5, 2, _7$$5);
zephir_check_call_status();
zephir_throw_exception_debug(_6$$5, "yb/std.zep", 287 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
zephir_array_update_multi(&arr, &v TSRMLS_CC, SL("za"), 2, groupValue);
}
RETURN_CCTOR(arr);
}
/**
* Generates SQL to drop a table
*/
PHP_METHOD(Phalcon_Db_Dialect_Oracle, dropTable) {
int ZEPHIR_LAST_CALL_STATUS;
zend_bool ifExists;
zval *tableName_param = NULL, *schemaName_param = NULL, *ifExists_param = NULL, *table = NULL;
zval *tableName = NULL, *schemaName = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 1, &tableName_param, &schemaName_param, &ifExists_param);
if (unlikely(Z_TYPE_P(tableName_param) != IS_STRING && Z_TYPE_P(tableName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'tableName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(tableName_param) == IS_STRING)) {
zephir_get_strval(tableName, tableName_param);
} else {
ZEPHIR_INIT_VAR(tableName);
ZVAL_EMPTY_STRING(tableName);
}
if (unlikely(Z_TYPE_P(schemaName_param) != IS_STRING && Z_TYPE_P(schemaName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'schemaName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(schemaName_param) == IS_STRING)) {
zephir_get_strval(schemaName, schemaName_param);
} else {
ZEPHIR_INIT_VAR(schemaName);
ZVAL_EMPTY_STRING(schemaName);
}
if (!ifExists_param) {
ifExists = 1;
} else {
if (unlikely(Z_TYPE_P(ifExists_param) != IS_BOOL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'ifExists' must be a bool") TSRMLS_CC);
RETURN_MM_NULL();
}
ifExists = Z_BVAL_P(ifExists_param);
}
ZEPHIR_CALL_METHOD(&table, this_ptr, "preparetable", NULL, 0, tableName, schemaName);
zephir_check_call_status();
if (ifExists) {
ZEPHIR_CONCAT_SV(return_value, "DROP TABLE IF EXISTS ", table);
RETURN_MM();
}
ZEPHIR_CONCAT_SV(return_value, "DROP TABLE ", table);
RETURN_MM();
}
/**
* Returns the active version (string)
*
* <code>
* echo Phalcon\Version::get();
* </code>
*/
PHP_METHOD(Phalcon_Version, get) {
zval version, major, medium, minor, special, specialNumber, result, suffix, _1$$3, _2$$4;
zephir_fcall_cache_entry *_0 = NULL;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *this_ptr = getThis();
ZVAL_UNDEF(&version);
ZVAL_UNDEF(&major);
ZVAL_UNDEF(&medium);
ZVAL_UNDEF(&minor);
ZVAL_UNDEF(&special);
ZVAL_UNDEF(&specialNumber);
ZVAL_UNDEF(&result);
ZVAL_UNDEF(&suffix);
ZVAL_UNDEF(&_1$$3);
ZVAL_UNDEF(&_2$$4);
ZEPHIR_MM_GROW();
ZEPHIR_CALL_STATIC(&version, "_getversion", NULL, 0);
zephir_check_call_status();
ZEPHIR_OBS_VAR(&major);
zephir_array_fetch_long(&major, &version, 0, PH_NOISY, "phalcon/version.zep", 127 TSRMLS_CC);
ZEPHIR_OBS_VAR(&medium);
zephir_array_fetch_long(&medium, &version, 1, PH_NOISY, "phalcon/version.zep", 128 TSRMLS_CC);
ZEPHIR_OBS_VAR(&minor);
zephir_array_fetch_long(&minor, &version, 2, PH_NOISY, "phalcon/version.zep", 129 TSRMLS_CC);
ZEPHIR_OBS_VAR(&special);
zephir_array_fetch_long(&special, &version, 3, PH_NOISY, "phalcon/version.zep", 130 TSRMLS_CC);
ZEPHIR_OBS_VAR(&specialNumber);
zephir_array_fetch_long(&specialNumber, &version, 4, PH_NOISY, "phalcon/version.zep", 131 TSRMLS_CC);
ZEPHIR_INIT_VAR(&result);
ZEPHIR_CONCAT_VSVSV(&result, &major, ".", &medium, ".", &minor);
ZEPHIR_CALL_STATIC(&suffix, "_getspecial", &_0, 460, &special);
zephir_check_call_status();
if (!ZEPHIR_IS_STRING(&suffix, "")) {
ZEPHIR_INIT_VAR(&_1$$3);
ZEPHIR_CONCAT_SV(&_1$$3, "-", &suffix);
zephir_concat_self(&result, &_1$$3 TSRMLS_CC);
if (!ZEPHIR_IS_LONG(&specialNumber, 0)) {
ZEPHIR_INIT_VAR(&_2$$4);
ZEPHIR_CONCAT_SV(&_2$$4, ".", &specialNumber);
zephir_concat_self(&result, &_2$$4 TSRMLS_CC);
}
}
RETURN_CCTOR(&result);
}
PHP_METHOD(Test_BuiltIn_StringMethods, getLength5) {
zval *a_param = NULL;
zval a, _0;
zval this_zv;
zval *this_ptr = getThis();
if (EXPECTED(this_ptr)) {
ZVAL_OBJ(&this_zv, Z_OBJ_P(this_ptr));
this_ptr = &this_zv;
} else this_ptr = NULL;
ZVAL_UNDEF(&a);
ZVAL_UNDEF(&_0);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &a_param);
zephir_get_strval(&a, a_param);
ZEPHIR_INIT_VAR(&_0);
ZEPHIR_CONCAT_SV(&_0, "hello", &a);
RETURN_MM_LONG(zephir_fast_strlen_ev(&_0));
}
/**
* Computes a HMAC
*
* @param string data
* @param string key
* @param string algo
* @param boolean raw
*/
PHP_METHOD(Phalcon_Security, computeHmac) {
zephir_nts_static zephir_fcall_cache_entry *_2 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zend_bool raw;
zval *data, *key, *algo, *raw_param = NULL, *hmac = NULL, *_0, *_1;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 1, &data, &key, &algo, &raw_param);
if (!raw_param) {
raw = 0;
} else {
raw = zephir_get_boolval(raw_param);
}
ZEPHIR_CALL_FUNCTION(&hmac, "hash_hmac", NULL, algo, data, key, (raw ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false)));
zephir_check_call_status();
if (!(zephir_is_true(hmac))) {
ZEPHIR_INIT_VAR(_0);
object_init_ex(_0, phalcon_security_exception_ce);
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_SV(_1, "Unknown hashing algorithm: %s", algo);
ZEPHIR_CALL_METHOD(NULL, _0, "__construct", &_2, _1);
zephir_check_call_status();
zephir_throw_exception_debug(_0, "phalcon/security.zep", 434 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
RETURN_CCTOR(hmac);
}
/**
* {@inheritDoc}
*/
PHP_METHOD(Pdm_Db_AbstractDialect, rollbackSavepoint) {
zval *name_param = NULL;
zval *name = NULL;
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 (unlikely(Z_TYPE_P(name_param) == IS_STRING)) {
name = name_param;
} else {
ZEPHIR_INIT_VAR(name);
ZVAL_EMPTY_STRING(name);
}
ZEPHIR_CONCAT_SV(return_value, "ROLLBACK TO SAVEPOINT ", name);
RETURN_MM();
}
/**
* Returns an HTML string of debugging information about any number of
* variables, each wrapped in a "pre" tag.
*
* <code>
* $foo = "string";
* $bar = ["key" => "value"];
* $baz = new stdClass();
* echo (new \Phalcon\Debug\Dump())->variables($foo, $bar, $baz);
*</code>
*
* @param mixed variable
* @param ...
*/
PHP_METHOD(Phalcon_Debug_Dump, variables) {
HashTable *_2;
HashPosition _1;
zval *key = NULL, *value = NULL, *output = NULL, *_0 = NULL, **_3, *_4$$3 = NULL, *_5$$3 = NULL;
zephir_fcall_cache_entry *_6 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(output);
ZVAL_STRING(output, "", 1);
ZEPHIR_CALL_FUNCTION(&_0, "func_get_args", NULL, 174);
zephir_check_call_status();
zephir_is_iterable(_0, &_2, &_1, 0, 0, "phalcon/debug/dump.zep", 297);
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(value, _3);
ZEPHIR_INIT_LNVAR(_5$$3);
ZEPHIR_CONCAT_SV(_5$$3, "var ", key);
ZEPHIR_CALL_METHOD(&_4$$3, this_ptr, "one", &_6, 0, value, _5$$3);
zephir_check_call_status();
zephir_concat_self(&output, _4$$3 TSRMLS_CC);
}
RETURN_CCTOR(output);
}
PHP_METHOD(Test_Oo_OoDynamicA, getNew) {
zend_class_entry *_1;
zval className, fullClassName, _0;
int ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_INIT_THIS();
ZVAL_UNDEF(&className);
ZVAL_UNDEF(&fullClassName);
ZVAL_UNDEF(&_0);
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(&className);
zephir_get_called_class(&className TSRMLS_CC);
ZEPHIR_INIT_VAR(&fullClassName);
ZEPHIR_CONCAT_SV(&fullClassName, "\\", &className);
zephir_fetch_safe_class(_0, fullClassName);
_1 = zephir_fetch_class_str_ex(Z_STRVAL_P(&_0), Z_STRLEN_P(&_0), ZEND_FETCH_CLASS_AUTO);
object_init_ex(return_value, _1);
if (zephir_has_constructor(return_value TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 0);
zephir_check_call_status();
}
RETURN_MM();
}
/**
* Writes parsed annotations to XCache
*/
PHP_METHOD(Phalcon_Annotations_Adapter_Xcache, write) {
int ZEPHIR_LAST_CALL_STATUS;
zval *key_param = NULL, *data, *_0, *_2 = NULL;
zval *key = NULL, *_1;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &key_param, &data);
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);
}
ZEPHIR_INIT_VAR(_0);
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_SV(_1, "_PHAN", key);
zephir_fast_strtolower(_0, _1);
ZEPHIR_CALL_FUNCTION(&_2, "serialize", NULL, 11, data);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(NULL, "xcache_set", NULL, 12, _0, _2);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* The kick command applies only to the currently used tube.
*/
PHP_METHOD(Phalcon_Queue_Beanstalk, kick) {
zval *_1;
zval *bound_param = NULL, *response = NULL, _0, *_2, *_3;
int bound, ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &bound_param);
bound = zephir_get_intval(bound_param);
ZEPHIR_SINIT_VAR(_0);
ZVAL_LONG(&_0, bound);
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_SV(_1, "kick ", &_0);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "write", NULL, 0, _1);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&response, this_ptr, "readstatus", NULL, 409);
zephir_check_call_status();
zephir_array_fetch_long(&_2, response, 0, PH_NOISY | PH_READONLY, "phalcon/queue/beanstalk.zep", 306 TSRMLS_CC);
if (!ZEPHIR_IS_STRING(_2, "KICKED")) {
RETURN_MM_BOOL(0);
}
ZEPHIR_OBS_VAR(_3);
zephir_array_fetch_long(&_3, response, 1, PH_NOISY, "phalcon/queue/beanstalk.zep", 310 TSRMLS_CC);
RETURN_MM_LONG(zephir_get_intval(_3));
}
/**
* Get stats of a tube.
*/
PHP_METHOD(Phalcon_Queue_Beanstalk, statsTube) {
int ZEPHIR_LAST_CALL_STATUS;
zval *tube_param = NULL, *response = NULL, *_1, *_2;
zval *tube = NULL, *_0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &tube_param);
if (unlikely(Z_TYPE_P(tube_param) != IS_STRING && Z_TYPE_P(tube_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'tube' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(tube_param) == IS_STRING)) {
zephir_get_strval(tube, tube_param);
} else {
ZEPHIR_INIT_VAR(tube);
ZVAL_EMPTY_STRING(tube);
}
ZEPHIR_INIT_VAR(_0);
ZEPHIR_CONCAT_SV(_0, "stats-tube ", tube);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "write", NULL, 0, _0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&response, this_ptr, "readyaml", NULL, 384);
zephir_check_call_status();
zephir_array_fetch_long(&_1, response, 0, PH_NOISY | PH_READONLY, "phalcon/queue/beanstalk.zep", 249 TSRMLS_CC);
if (!ZEPHIR_IS_STRING(_1, "OK")) {
RETURN_MM_BOOL(0);
}
zephir_array_fetch_long(&_2, response, 2, PH_NOISY | PH_READONLY, "phalcon/queue/beanstalk.zep", 253 TSRMLS_CC);
RETURN_CTOR(_2);
}
/**
* Flush Memcache data and resets internal meta-data in order to regenerate it
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Libmemcached, reset) {
HashTable *_2$$3;
HashPosition _1$$3;
zval *meta = NULL, *key = NULL, *realKey = NULL, *_0$$3 = NULL, **_3$$3, *_4$$4;
zephir_fcall_cache_entry *_5 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(meta);
zephir_read_property_this(&meta, this_ptr, SL("_metaData"), PH_NOISY_CC);
if (Z_TYPE_P(meta) == IS_ARRAY) {
ZEPHIR_INIT_VAR(_0$$3);
zephir_is_iterable(meta, &_2$$3, &_1$$3, 0, 0, "phalcon/mvc/model/metadata/libmemcached.zep", 132);
for (
; zephir_hash_get_current_data_ex(_2$$3, (void**) &_3$$3, &_1$$3) == SUCCESS
; zephir_hash_move_forward_ex(_2$$3, &_1$$3)
) {
ZEPHIR_GET_HMKEY(key, _2$$3, _1$$3);
ZEPHIR_GET_HVALUE(_0$$3, _3$$3);
ZEPHIR_INIT_NVAR(realKey);
ZEPHIR_CONCAT_SV(realKey, "meta-", key);
_4$$4 = zephir_fetch_nproperty_this(this_ptr, SL("_memcache"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, _4$$4, "delete", NULL, 0, realKey);
zephir_check_call_status();
}
}
ZEPHIR_CALL_PARENT(NULL, phalcon_mvc_model_metadata_libmemcached_ce, this_ptr, "reset", &_5, 336);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* Computes a HMAC
*
* @param string data
* @param string key
* @param string algo
* @param boolean raw
*/
PHP_METHOD(Phalcon_Security, computeHmac) {
int ZEPHIR_LAST_CALL_STATUS;
zend_bool raw;
zval *data, *key, *algo, *raw_param = NULL, *hmac = NULL, _0, *_1$$3, *_2$$3;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 1, &data, &key, &algo, &raw_param);
if (!raw_param) {
raw = 0;
} else {
raw = zephir_get_boolval(raw_param);
}
ZEPHIR_SINIT_VAR(_0);
ZVAL_BOOL(&_0, (raw ? 1 : 0));
ZEPHIR_CALL_FUNCTION(&hmac, "hash_hmac", NULL, 397, algo, data, key, &_0);
zephir_check_call_status();
if (!(zephir_is_true(hmac))) {
ZEPHIR_INIT_VAR(_1$$3);
object_init_ex(_1$$3, phalcon_security_exception_ce);
ZEPHIR_INIT_VAR(_2$$3);
ZEPHIR_CONCAT_SV(_2$$3, "Unknown hashing algorithm: %s", algo);
ZEPHIR_CALL_METHOD(NULL, _1$$3, "__construct", NULL, 9, _2$$3);
zephir_check_call_status();
zephir_throw_exception_debug(_1$$3, "phalcon/security.zep", 441 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
RETURN_CCTOR(hmac);
}
/**
* Reads meta-data from $_SESSION
*
* @param string key
* @return array
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Session, read) {
zval *key_param = NULL, *metaData, *_SESSION, *_0, *_1, *_2;
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);
}
zephir_get_global(&_SESSION, SS("_SESSION") TSRMLS_CC);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_2);
ZEPHIR_CONCAT_SV(_2, "$PMM$", _1);
zephir_array_fetch(&_0, _SESSION, _2, PH_READONLY, "phalcon/mvc/model/metadata/session.zep", 70 TSRMLS_CC);
if (zephir_array_isset_fetch(&metaData, _0, key, 1 TSRMLS_CC)) {
RETURN_CTOR(metaData);
}
RETURN_MM_NULL();
}
/**
* Writes the meta-data to $_SESSION
*
* @param string key
* @param array data
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Session, write) {
zval *key_param = NULL, *data, *_SESSION, *_0, *_1;
zval *key = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &key_param, &data);
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);
}
zephir_get_global(&_SESSION, SS("_SESSION") TSRMLS_CC);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_SV(_1, "$PMM$", _0);
zephir_array_update_multi(&_SESSION, &data TSRMLS_CC, SL("zz"), 2, _1, key);
ZEPHIR_MM_RESTORE();
}
/**
* Generates the SQL for LIMIT clause
*/
PHP_METHOD(Phalcon_Db_Dialect_Oracle, limit) {
int limit, offset = 0;
zval *sqlQuery_param = NULL, *number, *_0 = NULL, *_1, _2 = zval_used_for_init, *_3, _4 = zval_used_for_init, _6;
zval *sqlQuery = NULL, *_5, *_7;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &sqlQuery_param, &number);
if (unlikely(Z_TYPE_P(sqlQuery_param) != IS_STRING && Z_TYPE_P(sqlQuery_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'sqlQuery' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(sqlQuery_param) == IS_STRING)) {
zephir_get_strval(sqlQuery, sqlQuery_param);
} else {
ZEPHIR_INIT_VAR(sqlQuery);
ZVAL_EMPTY_STRING(sqlQuery);
}
if (Z_TYPE_P(number) == IS_ARRAY) {
if (zephir_array_isset_long(number, 1)) {
ZEPHIR_INIT_VAR(_0);
zephir_array_fetch_long(&_1, number, 1, PH_NOISY | PH_READONLY, "phalcon/db/dialect/oracle.zep", 51 TSRMLS_CC);
ZEPHIR_SINIT_VAR(_2);
ZVAL_STRING(&_2, "'", 0);
zephir_fast_trim(_0, _1, &_2, ZEPHIR_TRIM_BOTH TSRMLS_CC);
offset = zephir_get_intval(_0);
}
ZEPHIR_INIT_NVAR(_0);
zephir_array_fetch_long(&_1, number, 0, PH_NOISY | PH_READONLY, "phalcon/db/dialect/oracle.zep", 54 TSRMLS_CC);
ZEPHIR_SINIT_NVAR(_2);
ZVAL_STRING(&_2, "'", 0);
zephir_fast_trim(_0, _1, &_2, ZEPHIR_TRIM_BOTH TSRMLS_CC);
limit = (zephir_get_intval(_0) + offset);
} else {
ZEPHIR_INIT_VAR(_3);
ZEPHIR_SINIT_VAR(_4);
ZVAL_STRING(&_4, "'", 0);
zephir_fast_trim(_3, number, &_4, ZEPHIR_TRIM_BOTH TSRMLS_CC);
limit = zephir_get_intval(_3);
}
ZEPHIR_SINIT_NVAR(_4);
ZVAL_LONG(&_4, limit);
ZEPHIR_INIT_VAR(_5);
ZEPHIR_CONCAT_SVSVS(_5, "SELECT * FROM (SELECT Z1.*, ROWNUM PHALCON_RN FROM (", sqlQuery, ") Z1 WHERE ROWNUM <= ", &_4, ")");
ZEPHIR_CPY_WRT(sqlQuery, _5);
if (offset != 0) {
ZEPHIR_SINIT_VAR(_6);
ZVAL_LONG(&_6, offset);
ZEPHIR_INIT_VAR(_7);
ZEPHIR_CONCAT_SV(_7, " WHERE PHALCON_RN >= ", &_6);
zephir_concat_self(&sqlQuery, _7 TSRMLS_CC);
}
RETURN_CTOR(sqlQuery);
}
/**
* Dispatch a event to the listeners and behaviors
* This method expects that the endpoint listeners/behaviors returns true
* meaning that a least one was implemented
*/
PHP_METHOD(Phalcon_Mvc_Collection_Manager, missingMethod) {
int ZEPHIR_LAST_CALL_STATUS;
HashTable *_2;
HashPosition _1;
zval *eventName = NULL, *_4;
zval *model, *eventName_param = NULL, *data, *behaviors, *modelsBehaviors, *result = NULL, *eventsManager, *behavior = NULL, *_0, **_3;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 0, &model, &eventName_param, &data);
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);
}
ZEPHIR_OBS_VAR(behaviors);
zephir_read_property_this(&behaviors, this_ptr, SL("_behaviors"), PH_NOISY_CC);
if (Z_TYPE_P(behaviors) == IS_ARRAY) {
ZEPHIR_OBS_VAR(modelsBehaviors);
ZEPHIR_INIT_VAR(_0);
zephir_get_class(_0, model, 1 TSRMLS_CC);
if (zephir_array_isset_fetch(&modelsBehaviors, behaviors, _0, 0 TSRMLS_CC)) {
zephir_is_iterable(modelsBehaviors, &_2, &_1, 0, 0, "phalcon/mvc/collection/manager.zep", 325);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HVALUE(behavior, _3);
ZEPHIR_CALL_METHOD(&result, behavior, "missingmethod", NULL, 0, model, eventName, data);
zephir_check_call_status();
if (Z_TYPE_P(result) != IS_NULL) {
RETURN_CCTOR(result);
}
}
}
}
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(_4);
ZEPHIR_CONCAT_SV(_4, "model:", eventName);
ZEPHIR_RETURN_CALL_METHOD(eventsManager, "fire", NULL, 0, _4, model, data);
zephir_check_call_status();
RETURN_MM();
}
RETURN_MM_BOOL(0);
}
/**
* Appends a NOT BETWEEN condition to the current conditions
*
*<code>
* $criteria->notBetweenWhere('price', 100.25, 200.50);
*</code>
*/
PHP_METHOD(Phalcon_Mvc_Model_Criteria, notBetweenWhere) {
zval *_1;
int ZEPHIR_LAST_CALL_STATUS;
zval *expr_param = NULL, *minimum, *maximum, *hiddenParam = NULL, *nextHiddenParam = NULL, *minimumKey = NULL, *maximumKey = NULL, *_0;
zval *expr = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 0, &expr_param, &minimum, &maximum);
if (unlikely(Z_TYPE_P(expr_param) != IS_STRING && Z_TYPE_P(expr_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'expr' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(expr_param) == IS_STRING)) {
zephir_get_strval(expr, expr_param);
} else {
ZEPHIR_INIT_VAR(expr);
ZVAL_EMPTY_STRING(expr);
}
ZEPHIR_OBS_VAR(hiddenParam);
zephir_read_property_this(&hiddenParam, this_ptr, SL("_hiddenParamNumber"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(nextHiddenParam);
ZVAL_LONG(nextHiddenParam, (zephir_get_numberval(hiddenParam) + 1));
ZEPHIR_INIT_VAR(minimumKey);
ZEPHIR_CONCAT_SV(minimumKey, "ACP", hiddenParam);
ZEPHIR_INIT_VAR(maximumKey);
ZEPHIR_CONCAT_SV(maximumKey, "ACP", nextHiddenParam);
ZEPHIR_INIT_VAR(_0);
ZEPHIR_CONCAT_VSVSVS(_0, expr, " NOT BETWEEN :", minimumKey, ": AND :", maximumKey, ":");
ZEPHIR_INIT_VAR(_1);
zephir_create_array(_1, 2, 0 TSRMLS_CC);
zephir_array_update_zval(&_1, minimumKey, &minimum, PH_COPY);
zephir_array_update_zval(&_1, maximumKey, &maximum, PH_COPY);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "andwhere", NULL, 0, _0, _1);
zephir_check_call_status();
ZEPHIR_SEPARATE(nextHiddenParam);
zephir_increment(nextHiddenParam);
zephir_update_property_this(this_ptr, SL("_hiddenParamNumber"), nextHiddenParam TSRMLS_CC);
RETURN_THIS();
}
/**
* Appends a NOT IN condition to the current conditions
*
*<code>
* $criteria->notInWhere('id', [1, 2, 3]);
*</code>
*/
PHP_METHOD(Phalcon_Mvc_Model_Criteria, notInWhere) {
HashTable *_1;
HashPosition _0;
int ZEPHIR_LAST_CALL_STATUS;
zval *values = NULL;
zval *expr_param = NULL, *values_param = NULL, *hiddenParam = NULL, *bindParams = NULL, *bindKeys = NULL, *value = NULL, *key = NULL, **_2, *_4, *_5, *_3$$3 = NULL;
zval *expr = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &expr_param, &values_param);
if (unlikely(Z_TYPE_P(expr_param) != IS_STRING && Z_TYPE_P(expr_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'expr' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(expr_param) == IS_STRING)) {
zephir_get_strval(expr, expr_param);
} else {
ZEPHIR_INIT_VAR(expr);
ZVAL_EMPTY_STRING(expr);
}
values = values_param;
ZEPHIR_OBS_VAR(hiddenParam);
zephir_read_property_this(&hiddenParam, this_ptr, SL("_hiddenParamNumber"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(bindParams);
array_init(bindParams);
ZEPHIR_INIT_VAR(bindKeys);
array_init(bindKeys);
zephir_is_iterable(values, &_1, &_0, 0, 0, "phalcon/mvc/model/criteria.zep", 503);
for (
; zephir_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS
; zephir_hash_move_forward_ex(_1, &_0)
) {
ZEPHIR_GET_HVALUE(value, _2);
ZEPHIR_INIT_NVAR(key);
ZEPHIR_CONCAT_SV(key, "ACP", hiddenParam);
ZEPHIR_INIT_LNVAR(_3$$3);
ZEPHIR_CONCAT_SVS(_3$$3, ":", key, ":");
zephir_array_append(&bindKeys, _3$$3, PH_SEPARATE, "phalcon/mvc/model/criteria.zep", 493);
zephir_array_update_zval(&bindParams, key, &value, PH_COPY | PH_SEPARATE);
ZEPHIR_SEPARATE(hiddenParam);
zephir_increment(hiddenParam);
}
ZEPHIR_INIT_VAR(_4);
zephir_fast_join_str(_4, SL(", "), bindKeys TSRMLS_CC);
ZEPHIR_INIT_VAR(_5);
ZEPHIR_CONCAT_VSVS(_5, expr, " NOT IN (", _4, ")");
ZEPHIR_CALL_METHOD(NULL, this_ptr, "andwhere", NULL, 0, _5, bindParams);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_hiddenParamNumber"), hiddenParam TSRMLS_CC);
RETURN_THIS();
}
/**
* Reads the cookie-related info from the SESSION to restore the cookie as it was set
* This method is automatically called internally so normally you don't need to call it
*/
PHP_METHOD(Phalcon_Http_Cookie, restore) {
zval *dependencyInjector = NULL, *expire = NULL, *domain = NULL, *path = NULL, *secure = NULL, *httpOnly = NULL, *session = NULL, *definition = NULL, *_0, *_1$$4, *_2$$4 = NULL, *_3$$5, *_4$$5;
int ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_restored"), PH_NOISY_CC);
if (!(zephir_is_true(_0))) {
ZEPHIR_OBS_VAR(dependencyInjector);
zephir_read_property_this(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(dependencyInjector) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_1$$4);
ZVAL_STRING(_1$$4, "session", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&session, dependencyInjector, "getshared", NULL, 0, _1$$4);
zephir_check_temp_parameter(_1$$4);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_2$$4, session, "isstarted", NULL, 0);
zephir_check_call_status();
if (zephir_is_true(_2$$4)) {
_3$$5 = zephir_fetch_nproperty_this(this_ptr, SL("_name"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_4$$5);
ZEPHIR_CONCAT_SV(_4$$5, "_PHCOOKIE_", _3$$5);
ZEPHIR_CALL_METHOD(&definition, session, "get", NULL, 0, _4$$5);
zephir_check_call_status();
if (Z_TYPE_P(definition) == IS_ARRAY) {
if (zephir_array_isset_string_fetch(&expire, definition, SS("expire"), 1 TSRMLS_CC)) {
zephir_update_property_this(this_ptr, SL("_expire"), expire TSRMLS_CC);
}
if (zephir_array_isset_string_fetch(&domain, definition, SS("domain"), 1 TSRMLS_CC)) {
zephir_update_property_this(this_ptr, SL("_domain"), domain TSRMLS_CC);
}
if (zephir_array_isset_string_fetch(&path, definition, SS("path"), 1 TSRMLS_CC)) {
zephir_update_property_this(this_ptr, SL("_path"), path TSRMLS_CC);
}
if (zephir_array_isset_string_fetch(&secure, definition, SS("secure"), 1 TSRMLS_CC)) {
zephir_update_property_this(this_ptr, SL("_secure"), secure TSRMLS_CC);
}
if (zephir_array_isset_string_fetch(&httpOnly, definition, SS("httpOnly"), 1 TSRMLS_CC)) {
zephir_update_property_this(this_ptr, SL("_httpOnly"), httpOnly TSRMLS_CC);
}
}
}
}
if (1) {
zephir_update_property_this(this_ptr, SL("_restored"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
} else {
zephir_update_property_this(this_ptr, SL("_restored"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
}
}
RETURN_THIS();
}
/**
* Prepares event for execution by lazy-loading listener objects.
*
* @param string|\Xpl\Event\Event event The event ID or object to trigger.
* @return boolean|array False if no listeners, otherwise indexed array of the
* Event object (at index 0) and an array of listeners (at index 1).
*
* @throws \InvalidArgumentException if event is not a string or Event object.
*/
PHP_METHOD(Xpl_Event_Manager, prepare) {
zval *_4$$7;
int ZEPHIR_LAST_CALL_STATUS;
zval *event, *eventObj = NULL, *eventId = NULL, *listeners = NULL, *onceListener = NULL, *_3, *_0$$5, *_1$$5, *_2$$5;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &event);
if (Z_TYPE_P(event) == IS_STRING) {
ZEPHIR_CPY_WRT(eventId, event);
ZEPHIR_INIT_VAR(eventObj);
object_init_ex(eventObj, xpl_event_event_ce);
ZEPHIR_CALL_METHOD(NULL, eventObj, "__construct", NULL, 104, event);
zephir_check_call_status();
} else if (zephir_instance_of_ev(event, xpl_event_event_ce TSRMLS_CC)) {
ZEPHIR_CPY_WRT(eventObj, event);
ZEPHIR_CALL_METHOD(&eventId, event, "getid", NULL, 0);
zephir_check_call_status();
} else {
ZEPHIR_INIT_VAR(_0$$5);
object_init_ex(_0$$5, spl_ce_InvalidArgumentException);
ZEPHIR_INIT_VAR(_1$$5);
zephir_gettype(_1$$5, event TSRMLS_CC);
ZEPHIR_INIT_VAR(_2$$5);
ZEPHIR_CONCAT_SV(_2$$5, "Event must be string or instance of Event, given: ", _1$$5);
ZEPHIR_CALL_METHOD(NULL, _0$$5, "__construct", NULL, 5, _2$$5);
zephir_check_call_status();
zephir_throw_exception_debug(_0$$5, "xpl/event/manager.zep", 367 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
_3 = zephir_fetch_nproperty_this(this_ptr, SL("listeners"), PH_NOISY_CC);
if (!(zephir_array_isset_fetch(&listeners, _3, eventId, 1 TSRMLS_CC))) {
RETURN_MM_BOOL(0);
}
if (zephir_array_isset_string_fetch(&onceListener, listeners, SS("one"), 1 TSRMLS_CC)) {
zephir_create_array(return_value, 2, 0 TSRMLS_CC);
zephir_array_fast_append(return_value, eventObj);
ZEPHIR_INIT_VAR(_4$$7);
zephir_create_array(_4$$7, 1, 0 TSRMLS_CC);
zephir_array_fast_append(_4$$7, onceListener);
zephir_array_fast_append(return_value, _4$$7);
RETURN_MM();
}
zephir_create_array(return_value, 2, 0 TSRMLS_CC);
zephir_array_fast_append(return_value, eventObj);
zephir_array_fast_append(return_value, listeners);
RETURN_MM();
}
/**
* Sets an attached file to be sent at the end of the request
*
* @param string filePath
* @param string attachmentName
* @return \Phalcon\Http\Response
*/
PHP_METHOD(Phalcon_Http_Response, setFileToSend) {
int ZEPHIR_LAST_CALL_STATUS;
zval *filePath_param = NULL, *attachmentName = NULL, *attachment = NULL, *basePath = NULL, *headers = NULL, *_0 = NULL, *_1;
zval *filePath = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 2, &filePath_param, &attachmentName, &attachment);
zephir_get_strval(filePath, filePath_param);
if (!attachmentName) {
attachmentName = ZEPHIR_GLOBAL(global_null);
}
if (!attachment) {
attachment = ZEPHIR_GLOBAL(global_true);
}
if (Z_TYPE_P(attachmentName) != IS_STRING) {
ZEPHIR_INIT_VAR(basePath);
zephir_basename(basePath, filePath TSRMLS_CC);
} else {
ZEPHIR_CPY_WRT(basePath, attachmentName);
}
if (zephir_is_true(attachment)) {
ZEPHIR_CALL_METHOD(&headers, this_ptr, "getheaders", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "Content-Description: File Transfer", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, headers, "setraw", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "Content-Type: application/octet-stream", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, headers, "setraw", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_SV(_1, "Content-Disposition: attachment; filename=", basePath);
ZEPHIR_CALL_METHOD(NULL, headers, "setraw", NULL, 0, _1);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "Content-Transfer-Encoding: binary", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, headers, "setraw", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
}
zephir_update_property_this(this_ptr, SL("_file"), filePath TSRMLS_CC);
RETURN_THIS();
}
PHP_METHOD(PhalconPlus_Enum_Sys, init) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *moduleDir_param = NULL, *_0, *_1, _2, *_3 = NULL, *_6 = NULL, *_4$$4;
zval *moduleDir = NULL, *_5$$4;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &moduleDir_param);
if (UNEXPECTED(Z_TYPE_P(moduleDir_param) != IS_STRING && Z_TYPE_P(moduleDir_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'moduleDir' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(moduleDir_param) == IS_STRING)) {
zephir_get_strval(moduleDir, moduleDir_param);
} else {
ZEPHIR_INIT_VAR(moduleDir);
ZVAL_EMPTY_STRING(moduleDir);
}
ZEPHIR_OBS_VAR(_0);
zephir_read_static_property_ce(&_0, phalconplus_enum_sys_ce, SL("primaryModuleDir") TSRMLS_CC);
if (!(ZEPHIR_IS_EMPTY(_0))) {
RETURN_MM_NULL();
}
ZEPHIR_INIT_VAR(_1);
ZEPHIR_SINIT_VAR(_2);
ZVAL_STRING(&_2, "/", 0);
zephir_fast_trim(_1, moduleDir, &_2, ZEPHIR_TRIM_RIGHT TSRMLS_CC);
zephir_get_strval(moduleDir, _1);
ZEPHIR_CALL_FUNCTION(&_3, "is_dir", NULL, 39, moduleDir);
zephir_check_call_status();
if (!(zephir_is_true(_3))) {
ZEPHIR_INIT_VAR(_4$$4);
object_init_ex(_4$$4, zend_exception_get_default(TSRMLS_C));
ZEPHIR_INIT_VAR(_5$$4);
ZEPHIR_CONCAT_SV(_5$$4, "Module directory not exists or not a dir, file positon: ", moduleDir);
ZEPHIR_CALL_METHOD(NULL, _4$$4, "__construct", NULL, 7, _5$$4);
zephir_check_call_status();
zephir_throw_exception_debug(_4$$4, "phalconplus/Enum/Sys.zep", 28 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
zephir_update_static_property_ce(phalconplus_enum_sys_ce, SL("primaryModuleDir"), &moduleDir TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_6, "dirname", NULL, 71, moduleDir);
zephir_check_call_status();
zephir_update_static_property_ce(phalconplus_enum_sys_ce, SL("rootDir"), &_6 TSRMLS_CC);
RETURN_MM_NULL();
}
PHP_METHOD(Test_Concat, testConcat10) {
zval *url = NULL, *_0;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(url);
ZVAL_STRING(url, "test", 1);
ZEPHIR_INIT_VAR(_0);
ZEPHIR_CONCAT_SV(_0, "append", url);
ZEPHIR_CPY_WRT(url, _0);
RETURN_CCTOR(url);
}
PHP_METHOD(Auryn_AbstractCachingReflector, getCtorParams) {
int ZEPHIR_LAST_CALL_STATUS;
zval *className_param = NULL, *cacheKey, *reflectedCtorParams = NULL, *reflectedCtor = NULL, *_0, *_1, *_2;
zval *className = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &className_param);
if (unlikely(Z_TYPE_P(className_param) != IS_STRING && Z_TYPE_P(className_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'className' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (unlikely(Z_TYPE_P(className_param) == IS_STRING)) {
className = className_param;
} else {
ZEPHIR_INIT_VAR(className);
ZVAL_EMPTY_STRING(className);
}
ZEPHIR_INIT_VAR(_0);
zephir_fast_strtolower(_0, className);
ZEPHIR_INIT_VAR(cacheKey);
ZEPHIR_CONCAT_SV(cacheKey, "auryn.refls.ctor-params.", _0);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("cache"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&reflectedCtorParams, _1, "fetch", NULL, cacheKey);
zephir_check_call_status();
if (zephir_is_true(reflectedCtorParams)) {
RETURN_CCTOR(reflectedCtorParams);
} else {
ZEPHIR_CALL_METHOD(&reflectedCtor, this_ptr, "getctor", NULL, className);
zephir_check_call_status();
if (zephir_is_true(reflectedCtor)) {
ZEPHIR_CALL_METHOD(&reflectedCtorParams, reflectedCtor, "getparameters", NULL);
zephir_check_call_status();
} else {
ZEPHIR_INIT_BNVAR(reflectedCtorParams);
ZVAL_NULL(reflectedCtorParams);
}
}
_2 = zephir_fetch_nproperty_this(this_ptr, SL("cache"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, _2, "store", NULL, cacheKey, reflectedCtorParams);
zephir_check_call_status();
RETURN_CCTOR(reflectedCtorParams);
}
