/** * Return the error info, if any * * @return array */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, getErrorInfo) { int ZEPHIR_LAST_CALL_STATUS; zval *_0; ZEPHIR_MM_GROW(); _0 = zephir_fetch_nproperty_this(this_ptr, SL("_pdo"), PH_NOISY_CC); ZEPHIR_RETURN_CALL_METHOD(_0, "errorinfo", NULL); zephir_check_call_status(); RETURN_MM(); }
PHP_METHOD(PhalconPlus_Base_ModuleDef, getMode) { zval *_0; zend_long ZEPHIR_LAST_CALL_STATUS; ZEPHIR_MM_GROW(); _0 = zephir_fetch_nproperty_this(this_ptr, SL("runMode"), PH_NOISY_CC); ZEPHIR_RETURN_CALL_METHOD(_0, "getvalue", NULL, 0); zephir_check_call_status(); RETURN_MM(); }
/** * Checks whether internal connection is under an active transaction */ PHP_METHOD(Phalcon_Mvc_Model_Transaction, isValid) { zval *_0; int ZEPHIR_LAST_CALL_STATUS; ZEPHIR_MM_GROW(); _0 = zephir_fetch_nproperty_this(this_ptr, SL("_connection"), PH_NOISY_CC); ZEPHIR_RETURN_CALL_METHOD(_0, "isundertransaction", NULL, 0); zephir_check_call_status(); RETURN_MM(); }
/** * Returns a cached content * * @param int|string keyName * @param long lifetime * @return mixed */ PHP_METHOD(Phalcon_Cache_Backend_Mongo, get) { zephir_nts_static zephir_fcall_cache_entry *_4 = NULL; int ZEPHIR_LAST_CALL_STATUS; zval *_1; zval *keyName, *lifetime = NULL, *frontend, *prefixedKey, *conditions, *document = NULL, *cachedContent, *_0, *_2, *_3 = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &keyName, &lifetime); if (!lifetime) { lifetime = ZEPHIR_GLOBAL(global_null); } ZEPHIR_INIT_VAR(conditions); array_init(conditions); ZEPHIR_OBS_VAR(frontend); zephir_read_property_this(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC); _0 = zephir_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY_CC); ZEPHIR_INIT_VAR(prefixedKey); ZEPHIR_CONCAT_VV(prefixedKey, _0, keyName); zephir_update_property_this(this_ptr, SL("_lastKey"), prefixedKey TSRMLS_CC); zephir_array_update_string(&conditions, SL("key"), &prefixedKey, PH_COPY | PH_SEPARATE); ZEPHIR_INIT_VAR(_1); zephir_create_array(_1, 1, 0 TSRMLS_CC); ZEPHIR_INIT_VAR(_2); zephir_time(_2); zephir_array_update_string(&_1, SL("$gt"), &_2, PH_COPY | PH_SEPARATE); zephir_array_update_string(&conditions, SL("time"), &_1, PH_COPY | PH_SEPARATE); ZEPHIR_CALL_METHOD(&_3, this_ptr, "_getcollection", &_4); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&document, _3, "findone", NULL, conditions); zephir_check_call_status(); if (Z_TYPE_P(document) == IS_ARRAY) { ZEPHIR_OBS_VAR(cachedContent); if (zephir_array_isset_string_fetch(&cachedContent, document, SS("data"), 0 TSRMLS_CC)) { if (zephir_is_numeric(cachedContent)) { RETURN_CCTOR(cachedContent); } ZEPHIR_RETURN_CALL_METHOD(frontend, "afterretrieve", NULL, cachedContent); zephir_check_call_status(); RETURN_MM(); } else { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "The cache is corrupt", "phalcon/cache/backend/mongo.zep", 174); return; } } RETURN_MM_NULL(); }
PHP_METHOD(Test_McallChained, testChained1) { zval *_0 = NULL; int ZEPHIR_LAST_CALL_STATUS; ZEPHIR_MM_GROW(); ZEPHIR_CALL_METHOD(&_0, this_ptr, "testmethod1", NULL, 0); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(_0, "testmethod2", NULL, 0); zephir_check_call_status(); RETURN_MM(); }
/** * Adds a role to the ACL list. Second parameter allows inheriting access data from other existing role * * Example: * <code> * $acl->addRole( * new Phalcon\Acl\Role("administrator"), * "consultant" * ); * * $acl->addRole("administrator", "consultant"); * </code> * * @param array|string accessInherits * @param RoleInterface|string role */ PHP_METHOD(Phalcon_Acl_Adapter_Memory, addRole) { zend_bool _0; int ZEPHIR_LAST_CALL_STATUS; zval *role, *accessInherits = NULL, *roleName = NULL, *roleObject = NULL, *_1, *_2, *_3; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &role, &accessInherits); if (!accessInherits) { accessInherits = ZEPHIR_GLOBAL(global_null); } _0 = Z_TYPE_P(role) == IS_OBJECT; if (_0) { _0 = zephir_instance_of_ev(role, phalcon_acl_roleinterface_ce TSRMLS_CC); } if (_0) { ZEPHIR_CALL_METHOD(&roleName, role, "getname", NULL, 0); zephir_check_call_status(); ZEPHIR_CPY_WRT(roleObject, role); } else if (Z_TYPE_P(role) == IS_STRING) { ZEPHIR_CPY_WRT(roleName, role); ZEPHIR_INIT_NVAR(roleObject); object_init_ex(roleObject, phalcon_acl_role_ce); ZEPHIR_CALL_METHOD(NULL, roleObject, "__construct", NULL, 82, role); zephir_check_call_status(); } else { ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_acl_exception_ce, "Role must be either an string or implement RoleInterface", "phalcon/acl/adapter/memory.zep", 201); return; } _1 = zephir_fetch_nproperty_this(this_ptr, SL("_rolesNames"), PH_NOISY_CC); if (zephir_array_isset(_1, roleName)) { RETURN_MM_BOOL(0); } zephir_update_property_array_append(this_ptr, SL("_roles"), roleObject TSRMLS_CC); zephir_update_property_array(this_ptr, SL("_rolesNames"), roleName, ZEPHIR_GLOBAL(global_true) TSRMLS_CC); _2 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultAccess"), PH_NOISY_CC); ZEPHIR_INIT_VAR(_3); ZEPHIR_CONCAT_VS(_3, roleName, "!*!*"); zephir_update_property_array(this_ptr, SL("_access"), _3, _2 TSRMLS_CC); if (Z_TYPE_P(accessInherits) != IS_NULL) { ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addinherit", NULL, 0, roleName, accessInherits); zephir_check_call_status(); RETURN_MM(); } RETURN_MM_BOOL(1); }
PHP_METHOD(Yb_Db_Entity, primaryKeyValue) { zval *_0, *_1; int ZEPHIR_LAST_CALL_STATUS; ZEPHIR_MM_GROW(); _0 = zephir_fetch_nproperty_this(this_ptr, SL("model"), PH_NOISY_CC); _1 = zephir_fetch_nproperty_this(this_ptr, SL("row"), PH_NOISY_CC); ZEPHIR_RETURN_CALL_METHOD(_0, "pickprimarykeyvalue", NULL, 0, _1); zephir_check_call_status(); RETURN_MM(); }
/** * Gets a param by its name or numeric index * * @param mixed param * @param string|array filters * @param mixed defaultValue * @return mixed */ PHP_METHOD(Phalcon_Dispatcher, getParam) { int ZEPHIR_LAST_CALL_STATUS; zval *param, *filters = NULL, *defaultValue = NULL, *params, *filter = NULL, *paramValue, *dependencyInjector, *_0 = NULL, *_1, *_2 = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 2, ¶m, &filters, &defaultValue); if (!filters) { filters = ZEPHIR_GLOBAL(global_null); } if (!defaultValue) { defaultValue = ZEPHIR_GLOBAL(global_null); } ZEPHIR_OBS_VAR(params); zephir_read_property_this(¶ms, this_ptr, SL("_params"), PH_NOISY_CC); ZEPHIR_OBS_VAR(paramValue); if (zephir_array_isset_fetch(¶mValue, params, param, 0 TSRMLS_CC)) { if (Z_TYPE_P(filters) != IS_NULL) { 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(_0); ZVAL_STRING(_0, "A dependency injection object is required to access the 'filter' service", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_VAR(_1); ZVAL_LONG(_1, 0); ZEPHIR_CALL_METHOD(NULL, this_ptr, "_throwdispatchexception", NULL, _0, _1); zephir_check_temp_parameter(_0); zephir_check_call_status(); } ZEPHIR_INIT_NVAR(_0); ZVAL_STRING(_0, "filter", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_2, dependencyInjector, "getshared", NULL, _0); zephir_check_temp_parameter(_0); zephir_check_call_status(); ZEPHIR_CPY_WRT(filter, _2); ZEPHIR_RETURN_CALL_METHOD(filter, "sanitize", NULL, paramValue, filters); zephir_check_call_status(); RETURN_MM(); } else { RETURN_CCTOR(paramValue); } } RETVAL_ZVAL(defaultValue, 1, 0); RETURN_MM(); }
/** * Merges a configuration into the current one * *<code> * $appConfig = new \Phalcon\Config(array('database' => array('host' => 'localhost'))); * $globalConfig->merge($config2); *</code> */ PHP_METHOD(Phalcon_Config, merge) { int ZEPHIR_LAST_CALL_STATUS; zval *config; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &config); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "_merge", NULL, 22, config); zephir_check_call_status(); RETURN_MM(); }
PHP_METHOD(Yaf_Session, has) { int ZEPHIR_LAST_CALL_STATUS; zval *name; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &name); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "offsetexists", NULL, name); zephir_check_call_status(); RETURN_MM(); }
/** * Alias of `add` method */ PHP_METHOD(Phalcon_Validation, rule) { zend_long ZEPHIR_LAST_CALL_STATUS; zval *field, *validator; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &field, &validator); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "add", NULL, 0, field, validator); zephir_check_call_status(); RETURN_MM(); }
PHP_METHOD(Test_Mcall, testCall15) { int ZEPHIR_LAST_CALL_STATUS; zval *a, *b; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &b); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "testmethod6", NULL, a, b); zephir_check_call_status(); RETURN_MM(); }
PHP_METHOD(Test_Mcall, testCall17) { int ZEPHIR_LAST_CALL_STATUS; zval *c, *d; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &c, &d); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "testmethod4", NULL, c, d); zephir_check_call_status(); RETURN_MM(); }
/** * Returns the translation related to the given key * * @param string index * @param array placeholders * @param string domain * @return string */ PHP_METHOD(Phalcon_Translate_Adapter_Gettext, query) { int ZEPHIR_LAST_CALL_STATUS; zval *index_param = NULL, *placeholders = NULL, *translation = NULL, *domain = NULL, *_0 = NULL, _1; zval *index = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &index_param, &placeholders); if (unlikely(Z_TYPE_P(index_param) != IS_STRING && Z_TYPE_P(index_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'index' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(index_param) == IS_STRING)) { zephir_get_strval(index, index_param); } else { ZEPHIR_INIT_VAR(index); ZVAL_EMPTY_STRING(index); } if (!placeholders) { placeholders = ZEPHIR_GLOBAL(global_null); } ZEPHIR_CALL_FUNCTION(&_0, "func_num_args", NULL, 416); zephir_check_call_status(); if (ZEPHIR_GT_LONG(_0, 2)) { ZEPHIR_SINIT_VAR(_1); ZVAL_LONG(&_1, 2); ZEPHIR_CALL_FUNCTION(&domain, "func_get_arg", NULL, 415, &_1); zephir_check_call_status(); } else { ZEPHIR_INIT_NVAR(domain); ZVAL_NULL(domain); } if (!(zephir_is_true(domain))) { ZEPHIR_CALL_FUNCTION(&translation, "gettext", NULL, 418, index); zephir_check_call_status(); } else { ZEPHIR_CALL_FUNCTION(&translation, "dgettext", NULL, 419, domain, index); zephir_check_call_status(); } ZEPHIR_RETURN_CALL_METHOD(this_ptr, "replaceplaceholders", NULL, 0, translation, placeholders); zephir_check_call_status(); RETURN_MM(); }
/** * Gets an option by its name or numeric index * * @param mixed $option * @param string|array $filters * @param mixed $defaultValue */ PHP_METHOD(Phalcon_Cli_Dispatcher, getOption) { zend_long ZEPHIR_LAST_CALL_STATUS; zval *option, *filters = NULL, *defaultValue = NULL, *options = NULL, *filter = NULL, *optionValue = NULL, *dependencyInjector = NULL, *_2 = NULL, *_3, *_0$$5, *_1$$5; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 2, &option, &filters, &defaultValue); if (!filters) { filters = ZEPHIR_GLOBAL(global_null); } if (!defaultValue) { defaultValue = ZEPHIR_GLOBAL(global_null); } ZEPHIR_OBS_VAR(options); zephir_read_property_this(&options, this_ptr, SL("_options"), PH_NOISY_CC); ZEPHIR_OBS_VAR(optionValue); if (!(zephir_array_isset_fetch(&optionValue, options, option, 0 TSRMLS_CC))) { RETVAL_ZVAL(defaultValue, 1, 0); RETURN_MM(); } if (Z_TYPE_P(filters) == IS_NULL) { RETURN_CCTOR(optionValue); } 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(_0$$5); ZVAL_STRING(_0$$5, "A dependency injection object is required to access the 'filter' service", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_INIT_VAR(_1$$5); ZVAL_LONG(_1$$5, 0); ZEPHIR_CALL_METHOD(NULL, this_ptr, "_throwdispatchexception", NULL, 0, _0$$5, _1$$5); zephir_check_temp_parameter(_0$$5); zephir_check_call_status(); } ZEPHIR_INIT_VAR(_3); ZVAL_STRING(_3, "filter", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_CALL_METHOD(&_2, dependencyInjector, "getshared", NULL, 0, _3); zephir_check_temp_parameter(_3); zephir_check_call_status(); ZEPHIR_CPY_WRT(filter, _2); ZEPHIR_RETURN_CALL_METHOD(filter, "sanitize", NULL, 0, optionValue, filters); zephir_check_call_status(); RETURN_MM(); }
PHP_METHOD(Test_Mcall, testCall6) { zephir_nts_static zephir_fcall_cache_entry *_0 = NULL; int ZEPHIR_LAST_CALL_STATUS; zval *a, *b; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &b); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "testmethod6", &_0, a, b); zephir_check_call_status(); RETURN_MM(); }
PHP_METHOD(Test_McallChained, testChained4) { zval *_0, *_1 = NULL; int ZEPHIR_LAST_CALL_STATUS; ZEPHIR_MM_GROW(); zephir_update_property_this(this_ptr, SL("temp"), this_ptr TSRMLS_CC); _0 = zephir_fetch_nproperty_this(this_ptr, SL("temp"), PH_NOISY_CC); ZEPHIR_CALL_METHOD(&_1, _0, "testmethod1", NULL, 0); zephir_check_call_status(); ZEPHIR_RETURN_CALL_METHOD(_1, "testmethod2", NULL, 0); zephir_check_call_status(); RETURN_MM(); }
PHP_METHOD(Test_Issues, someMethod) { int ZEPHIR_LAST_CALL_STATUS; zval *methodName, *_0; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &methodName); _0 = zephir_fetch_nproperty_this(this_ptr, SL("adapter"), PH_NOISY_CC); ZEPHIR_RETURN_CALL_METHOD(_0, Z_STRVAL_P(methodName), NULL); zephir_check_call_status(); RETURN_MM(); }
/** * Render the image and return the binary string */ PHP_METHOD(Phalcon_Image_Adapter, render) { int quality, ZEPHIR_LAST_CALL_STATUS; zval *ext_param = NULL, *quality_param = NULL, *_0, _1, *_2 = NULL, *_4; zval *ext = NULL, *_3 = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 2, &ext_param, &quality_param); if (!ext_param) { ZEPHIR_INIT_VAR(ext); ZVAL_EMPTY_STRING(ext); } else { zephir_get_strval(ext, ext_param); } if (!quality_param) { quality = 100; } else { quality = zephir_get_intval(quality_param); } if (!(ext && Z_STRLEN_P(ext))) { _0 = zephir_fetch_nproperty_this(this_ptr, SL("_file"), PH_NOISY_CC); ZEPHIR_SINIT_VAR(_1); ZVAL_LONG(&_1, 4); ZEPHIR_CALL_FUNCTION(&_2, "pathinfo", NULL, 71, _0, &_1); zephir_check_call_status(); zephir_get_strval(_3, _2); ZEPHIR_CPY_WRT(ext, _3); } if (ZEPHIR_IS_EMPTY(ext)) { ZEPHIR_INIT_NVAR(ext); ZVAL_STRING(ext, "png", 1); } if (quality < 1) { quality = 1; } else if (quality > 100) { quality = 100; } ZEPHIR_INIT_VAR(_4); ZVAL_LONG(_4, quality); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "_render", NULL, 0, ext, _4); zephir_check_call_status(); RETURN_MM(); }
/** * Execute query and return result */ PHP_METHOD(Lynx_DBAL_Driver_PgSQL, execute) { int ZEPHIR_LAST_CALL_STATUS; zval *query_param = NULL, *e = NULL, *_0, *_1 = NULL; zval *query = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &query_param); if (unlikely(Z_TYPE_P(query_param) != IS_STRING && Z_TYPE_P(query_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'query' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (likely(Z_TYPE_P(query_param) == IS_STRING)) { zephir_get_strval(query, query_param); } else { ZEPHIR_INIT_VAR(query); ZVAL_EMPTY_STRING(query); } ZEPHIR_CALL_METHOD(NULL, this_ptr, "connect", NULL); zephir_check_call_status(); /* try_start_1: */ _0 = zephir_fetch_nproperty_this(this_ptr, SL("connection"), PH_NOISY_CC); ZEPHIR_RETURN_CALL_METHOD(_0, "exec", NULL, query); zephir_check_call_status_or_jump(try_end_1); RETURN_MM(); try_end_1: if (EG(exception)) { ZEPHIR_CPY_WRT(e, EG(exception)); if (zephir_instance_of_ev(e, zend_exception_get_default(TSRMLS_C) TSRMLS_CC)) { zend_clear_exception(TSRMLS_C); ZEPHIR_CALL_METHOD(&_1, e, "getmessage", NULL); zephir_check_call_status(); zephir_var_dump(&_1 TSRMLS_CC); zephir_exit_empty(); ZEPHIR_MM_RESTORE(); } } }
/** * Returns a new \Phalcon\Mvc\Model\Transaction or an already created once * This method registers a shutdown function to rollback active connections */ PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, get) { zval *_2$$4; zend_long ZEPHIR_LAST_CALL_STATUS; zval *autoBegin_param = NULL, *_0, *_4, *_1$$3, *_3$$4; zend_bool autoBegin; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &autoBegin_param); if (!autoBegin_param) { autoBegin = 1; } else { autoBegin = zephir_get_boolval(autoBegin_param); } _0 = zephir_fetch_nproperty_this(this_ptr, SL("_initialized"), PH_NOISY_CC); if (!(zephir_is_true(_0))) { _1$$3 = zephir_fetch_nproperty_this(this_ptr, SL("_rollbackPendent"), PH_NOISY_CC); if (zephir_is_true(_1$$3)) { ZEPHIR_INIT_VAR(_2$$4); zephir_create_array(_2$$4, 2, 0 TSRMLS_CC); zephir_array_fast_append(_2$$4, this_ptr); ZEPHIR_INIT_VAR(_3$$4); ZVAL_STRING(_3$$4, "rollbackPendent", 1); zephir_array_fast_append(_2$$4, _3$$4); ZEPHIR_CALL_FUNCTION(NULL, "register_shutdown_function", NULL, 382, _2$$4); zephir_check_call_status(); } if (1) { zephir_update_property_this(getThis(), SL("_initialized"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC); } else { zephir_update_property_this(getThis(), SL("_initialized"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC); } } ZEPHIR_INIT_VAR(_4); if (autoBegin) { ZVAL_BOOL(_4, 1); } else { ZVAL_BOOL(_4, 0); } ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getorcreatetransaction", NULL, 0, _4); zephir_check_call_status(); RETURN_MM(); }
/** * Checks whether the connection is under a transaction * *<code> * $connection->begin(); * var_dump($connection->isUnderTransaction()); //true *</code> */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, isUnderTransaction) { int ZEPHIR_LAST_CALL_STATUS; zval *pdo; ZEPHIR_MM_GROW(); ZEPHIR_OBS_VAR(pdo); zephir_read_property_this(&pdo, this_ptr, SL("_pdo"), PH_NOISY_CC); if (Z_TYPE_P(pdo) == IS_OBJECT) { ZEPHIR_RETURN_CALL_METHOD(pdo, "intransaction", NULL, 0); zephir_check_call_status(); RETURN_MM(); } RETURN_MM_BOOL(0); }
/** * Outputs a message */ PHP_METHOD(Phalcon_Flash_Direct, message) { int ZEPHIR_LAST_CALL_STATUS; zval *type_param = NULL, *message; zval *type = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &type_param, &message); zephir_get_strval(type, type_param); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "outputmessage", NULL, 0, type, message); zephir_check_call_status(); RETURN_MM(); }
/** * Returns the name of identity field (if one is present) * *<code> * print_r( * $metaData->getIdentityField( * new Robots() * ) * ); *</code> * * @param Phalcon\Mvc\ModelInterface model * @return string */ PHP_METHOD(Phalcon_Mvc_Model_MetaData, getIdentityField) { int ZEPHIR_LAST_CALL_STATUS; zval *model, *_0; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &model); ZEPHIR_INIT_VAR(_0); ZVAL_LONG(_0, 8); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "readmetadataindex", NULL, 11, model, _0); zephir_check_call_status(); RETURN_MM(); }
/** * {@inheritdoc} * * @param string sessionId * @return mixed */ PHP_METHOD(Phalcon_Session_Adapter_Memcache, read) { int ZEPHIR_LAST_CALL_STATUS; zval *sessionId, *_0, *_1; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &sessionId); _0 = zephir_fetch_nproperty_this(this_ptr, SL("_memcache"), PH_NOISY_CC); _1 = zephir_fetch_nproperty_this(this_ptr, SL("_lifetime"), PH_NOISY_CC); ZEPHIR_RETURN_CALL_METHOD(_0, "get", NULL, 0, sessionId, _1); zephir_check_call_status(); RETURN_MM(); }
/** * Generate the label of an element added to the form including HTML */ PHP_METHOD(Phalcon_Forms_Form, label) { zend_long ZEPHIR_LAST_CALL_STATUS; zval *attributes = NULL; zval *name_param = NULL, *attributes_param = NULL, *element = NULL, *_0, *_1; zval *name = NULL, *_2; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &name_param, &attributes_param); if (UNEXPECTED(Z_TYPE_P(name_param) != IS_STRING && Z_TYPE_P(name_param) != IS_NULL)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'name' must be a string") TSRMLS_CC); RETURN_MM_NULL(); } if (EXPECTED(Z_TYPE_P(name_param) == IS_STRING)) { zephir_get_strval(name, name_param); } else { ZEPHIR_INIT_VAR(name); ZVAL_EMPTY_STRING(name); } if (!attributes_param) { ZEPHIR_INIT_VAR(attributes); array_init(attributes); } else { zephir_get_arrval(attributes, attributes_param); } ZEPHIR_OBS_VAR(element); _0 = zephir_fetch_nproperty_this(this_ptr, SL("_elements"), PH_NOISY_CC); if (zephir_array_isset_fetch(&element, _0, name, 0 TSRMLS_CC)) { ZEPHIR_RETURN_CALL_METHOD(element, "label", NULL, 0, attributes); zephir_check_call_status(); RETURN_MM(); } ZEPHIR_INIT_VAR(_1); object_init_ex(_1, phalcon_forms_exception_ce); ZEPHIR_INIT_VAR(_2); ZEPHIR_CONCAT_SVS(_2, "Element with ID=", name, " is not part of the form"); ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, 9, _2); zephir_check_call_status(); zephir_throw_exception_debug(_1, "phalcon/forms/form.zep", 496 TSRMLS_CC); ZEPHIR_MM_RESTORE(); return; }
/** * Returns the status code * *<code> * print_r($response->getStatusCode()); *</code> */ PHP_METHOD(Phalcon_Http_Response, getStatusCode) { int ZEPHIR_LAST_CALL_STATUS; zval *_0 = NULL, *_1; ZEPHIR_MM_GROW(); ZEPHIR_CALL_METHOD(&_0, this_ptr, "getheaders", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_VAR(_1); ZVAL_STRING(_1, "Status", ZEPHIR_TEMP_PARAM_COPY); ZEPHIR_RETURN_CALL_METHOD(_0, "get", NULL, 0, _1); zephir_check_temp_parameter(_1); zephir_check_call_status(); RETURN_MM(); }
/** * Alias of `add` method */ PHP_METHOD(Phalcon_Validation, rule) { int ZEPHIR_LAST_CALL_STATUS; zval *field_param = NULL, *validator; zval *field = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &field_param, &validator); zephir_get_strval(field, field_param); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "add", NULL, 0, field, validator); zephir_check_call_status(); RETURN_MM(); }
/** * Alias: Removes a session variable from an application context */ PHP_METHOD(Phalcon_Session_Adapter, __unset) { int ZEPHIR_LAST_CALL_STATUS; zval *index_param = NULL; zval *index = NULL; ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &index_param); zephir_get_strval(index, index_param); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "remove", NULL, 0, index); zephir_check_call_status(); RETURN_MM(); }
/** * Returns the prefix for all the generated static urls. By default / */ PHP_METHOD(Phalcon_Mvc_Url, getStaticBaseUri) { zval *staticBaseUri = NULL; zend_long ZEPHIR_LAST_CALL_STATUS; ZEPHIR_MM_GROW(); ZEPHIR_OBS_VAR(staticBaseUri); zephir_read_property_this(&staticBaseUri, this_ptr, SL("_staticBaseUri"), PH_NOISY_CC); if (Z_TYPE_P(staticBaseUri) != IS_NULL) { RETURN_CCTOR(staticBaseUri); } ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getbaseuri", NULL, 0); zephir_check_call_status(); RETURN_MM(); }