/**
* Changes the fetching mode affecting Phalcon\Db\Result\Pdo::fetch()
*
*<code>
* //Return array with integer indexes
* $result->setFetchMode(Phalcon\Db::FETCH_NUM);
*
* //Return associative array without integer indexes
* $result->setFetchMode(Phalcon\Db::FETCH_ASSOC);
*
* //Return associative array together with integer indexes
* $result->setFetchMode(Phalcon\Db::FETCH_BOTH);
*
* //Return an object
* $result->setFetchMode(Phalcon\Db::FETCH_OBJ);
*</code>
*/
PHP_METHOD(Phalcon_Db_Result_Pdo, setFetchMode) {
zval *fetchMode_param = NULL, *pdoStatement, *_0 = NULL, *_1;
int fetchMode, ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &fetchMode_param);
fetchMode = zephir_get_intval(fetchMode_param);
ZEPHIR_OBS_VAR(pdoStatement);
zephir_read_property_this(&pdoStatement, this_ptr, SL("_pdoStatement"), PH_NOISY_CC);
do {
if (fetchMode == 2) {
ZEPHIR_INIT_VAR(_0);
ZVAL_LONG(_0, 4);
ZEPHIR_CALL_METHOD(NULL, pdoStatement, "setfetchmode", NULL, _0);
zephir_check_call_status();
ZEPHIR_INIT_ZVAL_NREF(_1);
ZVAL_LONG(_1, 4);
zephir_update_property_this(this_ptr, SL("_fetchMode"), _1 TSRMLS_CC);
break;
}
if (fetchMode == 1) {
ZEPHIR_INIT_NVAR(_0);
ZVAL_LONG(_0, 2);
ZEPHIR_CALL_METHOD(NULL, pdoStatement, "setfetchmode", NULL, _0);
zephir_check_call_status();
ZEPHIR_INIT_ZVAL_NREF(_1);
ZVAL_LONG(_1, 2);
zephir_update_property_this(this_ptr, SL("_fetchMode"), _1 TSRMLS_CC);
break;
}
if (fetchMode == 3) {
ZEPHIR_INIT_NVAR(_0);
ZVAL_LONG(_0, 3);
ZEPHIR_CALL_METHOD(NULL, pdoStatement, "setfetchmode", NULL, _0);
zephir_check_call_status();
ZEPHIR_INIT_ZVAL_NREF(_1);
ZVAL_LONG(_1, 3);
zephir_update_property_this(this_ptr, SL("_fetchMode"), _1 TSRMLS_CC);
break;
}
if (fetchMode == 4) {
ZEPHIR_INIT_NVAR(_0);
ZVAL_LONG(_0, 5);
ZEPHIR_CALL_METHOD(NULL, pdoStatement, "setfetchmode", NULL, _0);
zephir_check_call_status();
ZEPHIR_INIT_ZVAL_NREF(_1);
ZVAL_LONG(_1, 5);
zephir_update_property_this(this_ptr, SL("_fetchMode"), _1 TSRMLS_CC);
break;
}
} while(0);
ZEPHIR_MM_RESTORE();
}
/**
* Constructor.
*
* @param int defaultTtl
*/
PHP_METHOD(Xpl_Cache_Item, __construct) {
int expiry, defaultTtl;
zend_bool hit;
zval *key_param = NULL, *hit_param = NULL, *value, *expiry_param = NULL, *defaultTtl_param = NULL, *_0;
zval *key = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 2, &key_param, &hit_param, &value, &expiry_param, &defaultTtl_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);
}
if (unlikely(Z_TYPE_P(hit_param) != IS_BOOL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'hit' must be a bool") TSRMLS_CC);
RETURN_MM_NULL();
}
hit = Z_BVAL_P(hit_param);
if (!expiry_param) {
expiry = 0;
} else {
expiry = zephir_get_intval(expiry_param);
}
if (!defaultTtl_param) {
defaultTtl = 0;
} else {
defaultTtl = zephir_get_intval(defaultTtl_param);
}
zephir_update_property_this(this_ptr, SL("key"), key TSRMLS_CC);
if (hit) {
zephir_update_property_this(this_ptr, SL("hit"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
} else {
zephir_update_property_this(this_ptr, SL("hit"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
}
zephir_update_property_this(this_ptr, SL("value"), value TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_0);
ZVAL_LONG(_0, expiry);
zephir_update_property_this(this_ptr, SL("expires"), _0 TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_0);
ZVAL_LONG(_0, defaultTtl);
zephir_update_property_this(this_ptr, SL("defaultTtl"), _0 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Test_Assign, testPropertyAssignValuePlus1) {
zval *_0, *_1;
ZEPHIR_INIT_ZVAL_NREF(_0);
ZVAL_LONG(_0, 1);
zephir_update_property_this(this_ptr, SL("testVar"), _0 TSRMLS_CC);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("testVar"), PH_NOISY_CC);
ZEPHIR_INIT_ZVAL_NREF(_1);
ZVAL_LONG(_1, (zephir_get_numberval(_0) + 1));
zephir_update_property_this(this_ptr, SL("testVar"), _1 TSRMLS_CC);
RETURN_MEMBER(this_ptr, "testVar");
}
/**
* 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");
}
/**
* Rewinds the internal iterator
*/
PHP_METHOD(Phalcon_Forms_Form, rewind) {
zval *_0, *_1, *_2$$3, *_3$$3 = NULL, *_4$$4;
zend_long ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_ZVAL_NREF(_0);
ZVAL_LONG(_0, 0);
zephir_update_property_this(getThis(), SL("_position"), _0 TSRMLS_CC);
ZEPHIR_OBS_VAR(_1);
zephir_read_property_this(&_1, this_ptr, SL("_elements"), PH_NOISY_CC);
if (Z_TYPE_P(_1) == IS_ARRAY) {
_2$$3 = zephir_fetch_nproperty_this(this_ptr, SL("_elements"), PH_NOISY_CC);
ZEPHIR_CALL_FUNCTION(&_3$$3, "array_values", NULL, 231, _2$$3);
zephir_check_call_status();
zephir_update_property_this(getThis(), SL("_elementsIndexed"), _3$$3 TSRMLS_CC);
} else {
ZEPHIR_INIT_VAR(_4$$4);
array_init(_4$$4);
zephir_update_property_this(getThis(), SL("_elementsIndexed"), _4$$4 TSRMLS_CC);
}
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Test_Bench_Foo, write_prop) {
int _1;
zend_bool _0;
zval *n, *i = NULL, *_2 = NULL, *_3;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &n);
ZEPHIR_CPY_WRT(_2, n);
_1 = 1;
_0 = 0;
if (ZEPHIR_GE_LONG(_2, _1)) {
while (1) {
if (_0) {
_1++;
if (!(ZEPHIR_GE_LONG(_2, _1))) {
break;
}
} else {
_0 = 1;
}
ZEPHIR_INIT_NVAR(i);
ZVAL_LONG(i, _1);
ZEPHIR_INIT_ZVAL_NREF(_3);
ZVAL_LONG(_3, 0);
zephir_update_property_this(this_ptr, SL("b"), _3 TSRMLS_CC);
}
}
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Test_Concat, testConcatBySelfProperty) {
zval *title_param = NULL, _0;
zval title;
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(&title);
ZVAL_UNDEF(&_0);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &title_param);
zephir_get_strval(&title, title_param);
ZEPHIR_INIT_ZVAL_NREF(_0);
ZEPHIR_OBS_VAR(&_0);
zephir_read_static_property_ce(&_0, test_concat_ce, SL("testProperty"), PH_NOISY_CC);
zephir_concat_function(&title, &_0, &title);
zephir_update_static_property_ce(test_concat_ce, SL("testProperty"), &title);
ZEPHIR_MM_RESTORE();
}
/**
* Pdm\Db\Adapter constructor
*
* @param \PDO pdo
*/
PHP_METHOD(Pdm_Db_Adapter_AbstractPdo, __construct) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_nts_static zephir_fcall_cache_entry *_0 = NULL;
zval *pdo, *_1;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &pdo);
if (!(zephir_instance_of_ev(pdo, php_pdo_get_dbh_ce() TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "Parameter 'pdo' must be an instance of 'PDO'", "", 0);
return;
}
ZEPHIR_CALL_PARENT(NULL, pdm_db_adapter_abstractpdo_ce, this_ptr, "__construct", &_0);
zephir_check_call_status();
if (Z_TYPE_P(pdo) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(pdm_db_adapter_exception_ce, "A resource of PDO must be passed", "pdm/db/adapter/abstractpdo.zep", 51);
return;
}
zephir_update_property_this(this_ptr, SL("pdo"), pdo TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_1);
ZVAL_LONG(_1, 0);
zephir_update_property_this(this_ptr, SL("affectedRows"), _1 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Retrieve the method
* @return string
*/
PHP_METHOD(Yaf_Request_Abstract, getMethod) {
zend_bool _3;
zephir_nts_static zephir_fcall_cache_entry *_2 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *method = NULL, *sapiType = NULL, *_0, *_1 = NULL, _4, _5, *_6, *_7;
ZEPHIR_MM_GROW();
_0 = zephir_fetch_nproperty_this(this_ptr, SL("method"), PH_NOISY_CC);
if (Z_TYPE_P(_0) == IS_NULL) {
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "REQUEST_METHOD", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&method, this_ptr, "getserver", NULL, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
if (zephir_is_true(method)) {
zephir_update_property_this(this_ptr, SL("method"), method TSRMLS_CC);
} else {
ZEPHIR_CALL_FUNCTION(&sapiType, "php_sapi_name", &_2);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_1);
zephir_fast_strtolower(_1, sapiType);
_3 = ZEPHIR_IS_STRING(_1, "cli");
if (!(_3)) {
ZEPHIR_SINIT_VAR(_4);
ZVAL_LONG(&_4, 0);
ZEPHIR_SINIT_VAR(_5);
ZVAL_LONG(&_5, 3);
ZEPHIR_INIT_VAR(_6);
zephir_substr(_6, sapiType, 0 , 3 , 0);
_3 = ZEPHIR_IS_STRING(_6, "cgi");
}
if (_3) {
ZEPHIR_INIT_ZVAL_NREF(_7);
ZVAL_STRING(_7, "CLI", 1);
zephir_update_property_this(this_ptr, SL("method"), _7 TSRMLS_CC);
} else {
ZEPHIR_INIT_ZVAL_NREF(_7);
ZVAL_STRING(_7, "Unknown", 1);
zephir_update_property_this(this_ptr, SL("method"), _7 TSRMLS_CC);
}
}
}
RETURN_MM_MEMBER(this_ptr, "method");
}
PHP_METHOD(Xs_Command, setArg) {
zval *arg_param = NULL, *_0;
long arg;
zephir_fetch_params(0, 1, 0, &arg_param);
arg = zephir_get_intval(arg_param);
ZEPHIR_INIT_ZVAL_NREF(_0);
ZVAL_LONG(_0, (((arg >> 8)) & 0xff));
zephir_update_property_this(this_ptr, SL("arg1"), _0 TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_0);
ZVAL_LONG(_0, (arg & 0xff));
zephir_update_property_this(this_ptr, SL("arg2"), _0 TSRMLS_CC);
}
/**
* Rewinds the internal iterator
*/
PHP_METHOD(Phalcon_Annotations_Collection, rewind) {
zval *_0;
ZEPHIR_INIT_ZVAL_NREF(_0);
ZVAL_LONG(_0, 0);
zephir_update_property_this(this_ptr, SL("_position"), _0 TSRMLS_CC);
}
/**
* Rewinds the internal iterator
*/
PHP_METHOD(Phalcon_Validation_Message_Group, rewind) {
zval *_0;
ZEPHIR_INIT_ZVAL_NREF(_0);
ZVAL_LONG(_0, 0);
zephir_update_property_this(this_ptr, SL("_position"), _0 TSRMLS_CC);
}
/**
* Phalcon\Mvc\Model\Resultset\Simple constructor
*
* @param array columnMap
* @param Phalcon\Mvc\ModelInterface|Phalcon\Mvc\Model\Row model
* @param Phalcon\Db\Result\Pdo|null result
* @param Phalcon\Cache\BackendInterface cache
* @param boolean keepSnapshots
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset_Simple, __construct) {
int ZEPHIR_LAST_CALL_STATUS;
zval *columnMap, *model, *result, *cache = NULL, *keepSnapshots = NULL, *rowCount = NULL, *_0, *_1;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 2, &columnMap, &model, &result, &cache, &keepSnapshots);
if (!cache) {
cache = ZEPHIR_GLOBAL(global_null);
}
if (!keepSnapshots) {
keepSnapshots = ZEPHIR_GLOBAL(global_null);
}
zephir_update_property_this(this_ptr, SL("_model"), model TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_result"), result TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_cache"), cache TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_columnMap"), columnMap TSRMLS_CC);
if (Z_TYPE_P(result) != IS_OBJECT) {
RETURN_MM_NULL();
}
ZEPHIR_INIT_VAR(_0);
ZVAL_LONG(_0, 1);
ZEPHIR_CALL_METHOD(NULL, result, "setfetchmode", NULL, _0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&rowCount, result, "numrows", NULL);
zephir_check_call_status();
if (ZEPHIR_GT_LONG(rowCount, 32)) {
ZEPHIR_INIT_ZVAL_NREF(_1);
ZVAL_LONG(_1, 1);
zephir_update_property_this(this_ptr, SL("_type"), _1 TSRMLS_CC);
} else {
ZEPHIR_INIT_ZVAL_NREF(_1);
ZVAL_LONG(_1, 0);
zephir_update_property_this(this_ptr, SL("_type"), _1 TSRMLS_CC);
}
zephir_update_property_this(this_ptr, SL("_count"), rowCount TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_keepSnapshots"), keepSnapshots TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Xpl_Collection_Set, rewind) {
zval *_0;
ZEPHIR_INIT_ZVAL_NREF(_0);
ZVAL_LONG(_0, 0);
zephir_update_property_this(this_ptr, SL("iteratorPosition"), _0 TSRMLS_CC);
}
PHP_METHOD(Lynx_ORM_SqlBuilder, select) {
zval *_0;
ZEPHIR_INIT_ZVAL_NREF(_0);
ZVAL_LONG(_0, 1);
zephir_update_property_this(this_ptr, SL("type"), _0 TSRMLS_CC);
}
PHP_METHOD(Test_Assign, testPropertyDecr) {
zval *_0;
ZEPHIR_INIT_ZVAL_NREF(_0);
ZVAL_LONG(_0, 2);
zephir_update_property_this(this_ptr, SL("testVar"), _0 TSRMLS_CC);
RETURN_ON_FAILURE(zephir_property_decr(this_ptr, SL("testVar") TSRMLS_CC));
RETURN_MEMBER(this_ptr, "testVar");
}
/**
* Phalcon\Mvc\Model\Resultset constructor
*
* @param array columnTypes
* @param \Phalcon\Db\ResultInterface|false result
* @param \Phalcon\Cache\BackendInterface cache
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset, __construct) {
int ZEPHIR_LAST_CALL_STATUS;
zval *result, *cache = NULL, *rowCount = NULL, *rows = NULL, *_2, *_0$$3, *_1$$3, *_3$$5, *_4$$8;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &result, &cache);
if (!cache) {
cache = ZEPHIR_GLOBAL(global_null);
}
if (Z_TYPE_P(result) != IS_OBJECT) {
ZEPHIR_INIT_ZVAL_NREF(_0$$3);
ZVAL_LONG(_0$$3, 0);
zephir_update_property_this(this_ptr, SL("_count"), _0$$3 TSRMLS_CC);
ZEPHIR_INIT_VAR(_1$$3);
array_init(_1$$3);
zephir_update_property_this(this_ptr, SL("_rows"), _1$$3 TSRMLS_CC);
RETURN_MM_NULL();
}
zephir_update_property_this(this_ptr, SL("_result"), result TSRMLS_CC);
if (Z_TYPE_P(cache) != IS_NULL) {
zephir_update_property_this(this_ptr, SL("_cache"), cache TSRMLS_CC);
}
ZEPHIR_INIT_VAR(_2);
ZVAL_LONG(_2, 2);
ZEPHIR_CALL_METHOD(NULL, result, "setfetchmode", NULL, 0, _2);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&rowCount, result, "numrows", NULL, 0);
zephir_check_call_status();
zephir_update_property_this(this_ptr, SL("_count"), rowCount TSRMLS_CC);
if (ZEPHIR_IS_LONG(rowCount, 0)) {
ZEPHIR_INIT_VAR(_3$$5);
array_init(_3$$5);
zephir_update_property_this(this_ptr, SL("_rows"), _3$$5 TSRMLS_CC);
RETURN_MM_NULL();
}
if (ZEPHIR_LE_LONG(rowCount, 32)) {
ZEPHIR_CALL_METHOD(&rows, result, "fetchall", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(rows) == IS_ARRAY) {
zephir_update_property_this(this_ptr, SL("_rows"), rows TSRMLS_CC);
} else {
ZEPHIR_INIT_VAR(_4$$8);
array_init(_4$$8);
zephir_update_property_this(this_ptr, SL("_rows"), _4$$8 TSRMLS_CC);
}
}
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Test_Assign, testPropertyIncr1) {
zval *_0;
ZEPHIR_INIT_ZVAL_NREF(_0);
ZVAL_LONG(_0, 1);
zephir_update_property_this(this_ptr, SL("testVar"), _0 TSRMLS_CC);
zephir_increment(_0);
RETURN_MEMBER(this_ptr, "testVar");
}
PHP_METHOD(Test_Unsettest, testStdClassUnset) {
zval *simpleObject, *_0;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(simpleObject);
object_init(simpleObject);
ZEPHIR_INIT_ZVAL_NREF(_0);
ZVAL_LONG(_0, 12345);
zephir_update_property_zval(simpleObject, SL("property1"), _0 TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_0);
ZVAL_STRING(_0, "test", 1);
zephir_update_property_zval(simpleObject, SL("property2"), _0 TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_0);
ZVAL_LONG(_0, 12345);
zephir_update_property_zval(simpleObject, SL("property3"), _0 TSRMLS_CC);
zephir_unset_property(simpleObject, "property2" TSRMLS_CC);
RETURN_CCTOR(simpleObject);
}
/**
* Sets the expiration time for this cache item.
*
* @param \DateTimeInterface expiration
* The point in time after which the item MUST be considered expired.
* If null is passed explicitly, a default value MAY be used. If none is set,
* the value should be stored permanently or for as long as the
* implementation allows.
*
* @return \Xpl\Cache\Item The called object.
*/
PHP_METHOD(Xpl_Cache_Item, expiresAt) {
int ZEPHIR_LAST_CALL_STATUS;
zval *expiration, *_0$$3, *_1$$3, *_2$$3, *_3$$5 = NULL, *_4$$5, *_5$$5, *_6$$6, *_7$$6 = NULL, _8$$6, *_9$$6 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &expiration);
if (Z_TYPE_P(expiration) == IS_NULL) {
ZEPHIR_INIT_VAR(_0$$3);
zephir_time(_0$$3);
_1$$3 = zephir_fetch_nproperty_this(this_ptr, SL("defaultTtl"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_2$$3);
zephir_add_function(_2$$3, _0$$3, _1$$3);
zephir_update_property_this(this_ptr, SL("expires"), _2$$3 TSRMLS_CC);
} else {
if (zephir_is_instance_of(expiration, SL("DateTimeInterface") TSRMLS_CC)) {
ZEPHIR_INIT_VAR(_4$$5);
ZVAL_STRING(_4$$5, "U", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_3$$5, expiration, "format", NULL, 0, _4$$5);
zephir_check_temp_parameter(_4$$5);
zephir_check_call_status();
ZEPHIR_INIT_ZVAL_NREF(_5$$5);
ZVAL_LONG(_5$$5, zephir_get_intval(_3$$5));
zephir_update_property_this(this_ptr, SL("expires"), _5$$5 TSRMLS_CC);
} else {
ZEPHIR_INIT_VAR(_6$$6);
object_init_ex(_6$$6, xpl_cache_invalidargumentexception_ce);
ZEPHIR_INIT_VAR(_7$$6);
if (Z_TYPE_P(expiration) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_7$$6);
zephir_get_class(_7$$6, expiration, 0 TSRMLS_CC);
} else {
ZEPHIR_INIT_NVAR(_7$$6);
zephir_gettype(_7$$6, expiration TSRMLS_CC);
}
ZEPHIR_SINIT_VAR(_8$$6);
ZVAL_STRING(&_8$$6, "Expiration date must be null or instance of DateTimeInterface, given: \"%s\".", 0);
ZEPHIR_CALL_FUNCTION(&_9$$6, "sprintf", NULL, 41, &_8$$6, _7$$6);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, _6$$6, "__construct", NULL, 42, _9$$6);
zephir_check_call_status();
zephir_throw_exception_debug(_6$$6, "xpl/cache/item.zep", 147 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
}
RETURN_THIS();
}
PHP_METHOD(Test_Assign, testPropertyAssignStringConcat) {
zval *_0;
ZEPHIR_INIT_ZVAL_NREF(_0);
ZVAL_STRING(_0, "test", 1);
zephir_update_property_this(this_ptr, SL("testVar"), _0 TSRMLS_CC);
zephir_concat_self_str(&_0, " string", sizeof(" string")-1 TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("testVar"), _0 TSRMLS_CC);
RETURN_MEMBER(this_ptr, "testVar");
}
PHP_METHOD(PocketMine_Level_Generator_Noise_Generator, setOffset) {
zval *x_param = NULL, *y_param = NULL, *z_param = NULL, *_0;
double x, y, z;
zephir_fetch_params(0, 3, 0, &x_param, &y_param, &z_param);
x = zephir_get_doubleval(x_param);
y = zephir_get_doubleval(y_param);
z = zephir_get_doubleval(z_param);
ZEPHIR_INIT_ZVAL_NREF(_0);
ZVAL_DOUBLE(_0, x);
zephir_update_property_this(this_ptr, SL("offsetX"), _0 TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_0);
ZVAL_DOUBLE(_0, y);
zephir_update_property_this(this_ptr, SL("offsetY"), _0 TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_0);
ZVAL_DOUBLE(_0, z);
zephir_update_property_this(this_ptr, SL("offsetZ"), _0 TSRMLS_CC);
}
PHP_METHOD(Test_Typeoff, testClassPropertyAccess) {
zval *_0, *_1;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_ZVAL_NREF(_0);
ZVAL_STRING(_0, "test string", 1);
zephir_update_property_this(this_ptr, SL("property"), _0 TSRMLS_CC);
ZEPHIR_OBS_VAR(_1);
zephir_read_property_this(&_1, this_ptr, SL("property"), PH_NOISY_CC);
RETURN_MM_BOOL((Z_TYPE_P(_1) == IS_STRING));
}
/**
* Sets the default access level (Phalcon\Acl::ALLOW or Phalcon\Acl::DENY)
* for no arguments provided in isAllowed action if there exists func for
* accessKey
*/
PHP_METHOD(Phalcon_Acl_Adapter_Memory, setNoArgumentsDefaultAction) {
zval *defaultAccess_param = NULL, *_0;
int defaultAccess;
zephir_fetch_params(0, 1, 0, &defaultAccess_param);
defaultAccess = zephir_get_intval(defaultAccess_param);
ZEPHIR_INIT_ZVAL_NREF(_0);
ZVAL_LONG(_0, defaultAccess);
zephir_update_property_this(this_ptr, SL("_noArgumentsDefaultAction"), _0 TSRMLS_CC);
}
PHP_METHOD(Yb_Task_TaskManagerAbstract, setIdles) {
zval *idles_param = NULL, *_0;
long idles;
zephir_fetch_params(0, 1, 0, &idles_param);
idles = zephir_get_intval(idles_param);
ZEPHIR_INIT_ZVAL_NREF(_0);
ZVAL_LONG(_0, idles);
zephir_update_property_this(this_ptr, SL("idles"), _0 TSRMLS_CC);
}
PHP_METHOD(Yb_Task_TaskManagerAbstract, setSleep) {
zval *sleep_param = NULL, *_0;
long sleep;
zephir_fetch_params(0, 1, 0, &sleep_param);
sleep = zephir_get_intval(sleep_param);
ZEPHIR_INIT_ZVAL_NREF(_0);
ZVAL_LONG(_0, sleep);
zephir_update_property_this(this_ptr, SL("sleep"), _0 TSRMLS_CC);
}
/**
* Sets the default access level (Phalcon\Acl::ALLOW or Phalcon\Acl::DENY)
*/
PHP_METHOD(Phalcon_Acl_Adapter, setDefaultAction) {
zval *defaultAccess_param = NULL, *_0;
zend_long defaultAccess;
zephir_fetch_params(0, 1, 0, &defaultAccess_param);
defaultAccess = zephir_get_intval(defaultAccess_param);
ZEPHIR_INIT_ZVAL_NREF(_0);
ZVAL_LONG(_0, defaultAccess);
zephir_update_property_this(getThis(), SL("_defaultAccess"), _0 TSRMLS_CC);
}
/**
* Sets the HTML quoting type for htmlspecialchars
*
*<code>
* $escaper->setHtmlQuoteType(ENT_XHTML);
*</code>
*/
PHP_METHOD(Phalcon_Escaper, setHtmlQuoteType) {
zval *quoteType_param = NULL, *_0;
zend_long quoteType;
zephir_fetch_params(0, 1, 0, "eType_param);
quoteType = zephir_get_intval(quoteType_param);
ZEPHIR_INIT_ZVAL_NREF(_0);
ZVAL_LONG(_0, quoteType);
zephir_update_property_this(getThis(), SL("_htmlQuoteType"), _0 TSRMLS_CC);
}
/**
* Sets code for the message
*/
PHP_METHOD(Phalcon_Mvc_Model_Message, setCode) {
zval *code_param = NULL, *_0;
zend_long code;
zephir_fetch_params(0, 1, 0, &code_param);
code = zephir_get_intval(code_param);
ZEPHIR_INIT_ZVAL_NREF(_0);
ZVAL_LONG(_0, code);
zephir_update_property_this(getThis(), SL("_code"), _0 TSRMLS_CC);
RETURN_THISW();
}
/**
* Filters the logs sent to the handlers that are less or equal than a specific level
*/
PHP_METHOD(Phalcon_Logger_Adapter, setLogLevel) {
zval *level_param = NULL, *_0;
int level;
zephir_fetch_params(0, 1, 0, &level_param);
level = zephir_get_intval(level_param);
ZEPHIR_INIT_ZVAL_NREF(_0);
ZVAL_LONG(_0, level);
zephir_update_property_this(this_ptr, SL("_logLevel"), _0 TSRMLS_CC);
RETURN_THISW();
}
