/**
* Sets a prefix for all the URIs to be generated
*
*<code>
* $url->setBaseUri("/invo/");
*
* $url->setBaseUri("/invo/index.php/");
*</code>
*/
PHP_METHOD(Phalcon_Mvc_Url, setBaseUri) {
zval *baseUri_param = NULL, _0;
zval baseUri;
zval *this_ptr = getThis();
ZVAL_UNDEF(&baseUri);
ZVAL_UNDEF(&_0);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &baseUri_param);
if (UNEXPECTED(Z_TYPE_P(baseUri_param) != IS_STRING && Z_TYPE_P(baseUri_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'baseUri' must be of the type string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(baseUri_param) == IS_STRING)) {
zephir_get_strval(&baseUri, baseUri_param);
} else {
ZEPHIR_INIT_VAR(&baseUri);
ZVAL_EMPTY_STRING(&baseUri);
}
zephir_update_property_zval(this_ptr, SL("baseUri"), &baseUri);
zephir_read_property(&_0, this_ptr, SL("staticBaseUri"), PH_NOISY_CC | PH_READONLY);
if (Z_TYPE_P(&_0) == IS_NULL) {
zephir_update_property_zval(this_ptr, SL("staticBaseUri"), &baseUri);
}
RETURN_THIS();
}
PHP_METHOD(Test_Oo_PropertyAccess, __construct) {
zval *test, *test1, *_0, *_1, *_2, *_3, *_4, *_5, *_6, *_7 = NULL, *_8, *_9;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(test);
object_init(test);
ZEPHIR_INIT_VAR(_0);
array_init_size(_0, 6);
ZEPHIR_INIT_VAR(_1);
ZVAL_LONG(_1, 1);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 2);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 3);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_LONG(_1, 5);
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_BNVAR(_1);
ZVAL_DOUBLE(_1, 6.00);
zephir_array_fast_append(_0, _1);
zephir_update_property_zval(test, SL("test"), _0 TSRMLS_CC);
ZEPHIR_OBS_VAR(_2);
zephir_read_property(&_2, test, SL("test"), PH_NOISY_CC);
zephir_array_fetch_long(&_3, _2, 0, PH_NOISY | PH_READONLY TSRMLS_CC);
zephir_update_property_zval(test, SL("test2"), _3 TSRMLS_CC);
ZEPHIR_OBS_VAR(_4);
zephir_read_property(&_4, test, SL("test"), PH_NOISY_CC);
zephir_array_fetch_long(&_5, _4, 1, PH_NOISY | PH_READONLY TSRMLS_CC);
zephir_update_property_zval(test, SL("test3"), _5 TSRMLS_CC);
ZEPHIR_INIT_BNVAR(_1);
array_init_size(_1, 5);
ZEPHIR_OBS_VAR(_6);
zephir_read_property(&_6, test, SL("test"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(_7);
zephir_array_fetch_long(&_7, _6, 1, PH_NOISY TSRMLS_CC);
zephir_array_fast_append(_1, _7);
ZEPHIR_INIT_VAR(_8);
ZVAL_LONG(_8, 1);
zephir_array_fast_append(_1, _8);
ZEPHIR_INIT_BNVAR(_8);
ZVAL_LONG(_8, 2);
zephir_array_fast_append(_1, _8);
ZEPHIR_INIT_BNVAR(_8);
ZVAL_LONG(_8, 3);
zephir_array_fast_append(_1, _8);
zephir_update_property_zval(test, SL("test3"), _1 TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("a"), test TSRMLS_CC);
_9 = zephir_fetch_nproperty_this(this_ptr, SL("a"), PH_NOISY_CC);
ZEPHIR_OBS_NVAR(_7);
zephir_read_property(&_7, _9, SL("test2"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("b"), _7 TSRMLS_CC);
test1 = zephir_fetch_nproperty_this(this_ptr, SL("a"), PH_NOISY_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Phalcon\Di\Service
*
* @param mixed definition
*/
PHP_METHOD(Phalcon_Di_Service, __construct) {
zend_bool shared;
zval *definition, definition_sub, *shared_param = NULL, __$true, __$false;
zval *this_ptr = getThis();
ZVAL_UNDEF(&definition_sub);
ZVAL_BOOL(&__$true, 1);
ZVAL_BOOL(&__$false, 0);
zephir_fetch_params(0, 1, 1, &definition, &shared_param);
if (!shared_param) {
shared = 0;
} else {
shared = zephir_get_boolval(shared_param);
}
zephir_update_property_zval(this_ptr, SL("_definition"), definition);
if (shared) {
zephir_update_property_zval(this_ptr, SL("_shared"), &__$true);
} else {
zephir_update_property_zval(this_ptr, SL("_shared"), &__$false);
}
}
/**
* Sets the intermediate model data for has-*-through relations
*
* @param string|array intermediateFields
* @param string intermediateReferencedFields
*/
PHP_METHOD(Phalcon_Mvc_Model_Relation, setIntermediateRelation) {
zval intermediateModel;
zval *intermediateFields, intermediateFields_sub, *intermediateModel_param = NULL, *intermediateReferencedFields, intermediateReferencedFields_sub;
zval *this_ptr = getThis();
ZVAL_UNDEF(&intermediateFields_sub);
ZVAL_UNDEF(&intermediateReferencedFields_sub);
ZVAL_UNDEF(&intermediateModel);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 0, &intermediateFields, &intermediateModel_param, &intermediateReferencedFields);
if (UNEXPECTED(Z_TYPE_P(intermediateModel_param) != IS_STRING && Z_TYPE_P(intermediateModel_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'intermediateModel' must be of the type string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(intermediateModel_param) == IS_STRING)) {
zephir_get_strval(&intermediateModel, intermediateModel_param);
} else {
ZEPHIR_INIT_VAR(&intermediateModel);
ZVAL_EMPTY_STRING(&intermediateModel);
}
zephir_update_property_zval(this_ptr, SL("_intermediateFields"), intermediateFields);
zephir_update_property_zval(this_ptr, SL("_intermediateModel"), &intermediateModel);
zephir_update_property_zval(this_ptr, SL("_intermediateReferencedFields"), intermediateReferencedFields);
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Owl_Router_Router, add) {
int ZEPHIR_LAST_CALL_STATUS;
zend_bool _2;
zval *parameters = NULL;
zval *uri_param = NULL, *parameters_param = NULL, *method_param = NULL, *route, _0, *_1, _3, *_4;
zval *uri = NULL, *method = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 2, &uri_param, ¶meters_param, &method_param);
zephir_get_strval(uri, uri_param);
if (!parameters_param) {
ZEPHIR_INIT_VAR(parameters);
array_init(parameters);
} else {
parameters = parameters_param;
}
if (!method_param) {
ZEPHIR_INIT_VAR(method);
ZVAL_STRING(method, "GET", 1);
} else {
zephir_get_strval(method, method_param);
}
ZEPHIR_SINIT_VAR(_0);
ZVAL_STRING(&_0, "{", 0);
ZEPHIR_INIT_VAR(_1);
zephir_fast_strpos(_1, uri, &_0, 0 );
_2 = ZEPHIR_IS_FALSE_IDENTICAL(_1);
if (_2) {
ZEPHIR_SINIT_VAR(_3);
ZVAL_STRING(&_3, ":", 0);
ZEPHIR_INIT_VAR(_4);
zephir_fast_strpos(_4, uri, &_3, 0 );
_2 = ZEPHIR_IS_FALSE_IDENTICAL(_4);
}
ZEPHIR_INIT_VAR(route);
if (_2) {
object_init_ex(route, owl_router_http_staticroute_ce);
ZEPHIR_CALL_METHOD(NULL, route, "__construct", NULL, 27, uri);
zephir_check_call_status();
} else {
object_init_ex(route, owl_router_http_dynamicroute_ce);
ZEPHIR_CALL_METHOD(NULL, route, "__construct", NULL, 28, uri);
zephir_check_call_status();
}
zephir_update_property_zval(route, SL("method"), method TSRMLS_CC);
zephir_update_property_zval(route, SL("parameters"), parameters TSRMLS_CC);
zephir_update_property_array_append(this_ptr, SL("routers"), route TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Initializes the session bag. This method must not be called directly, the
* class calls it when its internal data is accessed
*/
PHP_METHOD(Phalcon_Session_Bag, initialize) {
zval __$true, __$false, session, dependencyInjector, data, _2, _1$$3;
zend_long ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_0 = NULL;
zval *this_ptr = getThis();
ZVAL_BOOL(&__$true, 1);
ZVAL_BOOL(&__$false, 0);
ZVAL_UNDEF(&session);
ZVAL_UNDEF(&dependencyInjector);
ZVAL_UNDEF(&data);
ZVAL_UNDEF(&_2);
ZVAL_UNDEF(&_1$$3);
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(&session);
zephir_read_property(&session, this_ptr, SL("_session"), PH_NOISY_CC);
if (Z_TYPE_P(&session) != IS_OBJECT) {
ZEPHIR_OBS_VAR(&dependencyInjector);
zephir_read_property(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(&dependencyInjector) != IS_OBJECT) {
ZEPHIR_CALL_CE_STATIC(&dependencyInjector, phalcon_di_ce, "getdefault", &_0, 0);
zephir_check_call_status();
if (Z_TYPE_P(&dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_session_exception_ce, "A dependency injection object is required to access the 'session' service", "phalcon/session/bag.zep", 212);
return;
}
}
ZEPHIR_INIT_VAR(&_1$$3);
ZVAL_STRING(&_1$$3, "session");
ZEPHIR_CALL_METHOD(&session, &dependencyInjector, "getshared", NULL, 0, &_1$$3);
zephir_check_call_status();
zephir_update_property_zval(this_ptr, SL("_session"), &session);
}
zephir_read_property(&_2, this_ptr, SL("_name"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_CALL_METHOD(&data, &session, "get", NULL, 0, &_2);
zephir_check_call_status();
if (Z_TYPE_P(&data) != IS_ARRAY) {
ZEPHIR_INIT_NVAR(&data);
array_init(&data);
}
zephir_update_property_zval(this_ptr, SL("_data"), &data);
if (1) {
zephir_update_property_zval(this_ptr, SL("_initialized"), &__$true);
} else {
zephir_update_property_zval(this_ptr, SL("_initialized"), &__$false);
}
ZEPHIR_MM_RESTORE();
}
/**
* Return the strategy to obtain the meta-data
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, getStrategy) {
zval _0, _1$$3;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *this_ptr = getThis();
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1$$3);
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(&_0);
zephir_read_property(&_0, this_ptr, SL("_strategy"), PH_NOISY_CC);
if (Z_TYPE_P(&_0) == IS_NULL) {
ZEPHIR_INIT_VAR(&_1$$3);
object_init_ex(&_1$$3, phalcon_mvc_model_metadata_strategy_introspection_ce);
if (zephir_has_constructor(&_1$$3 TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, &_1$$3, "__construct", NULL, 0);
zephir_check_call_status();
}
zephir_update_property_zval(this_ptr, SL("_strategy"), &_1$$3);
}
RETURN_MM_MEMBER(getThis(), "_strategy");
}
/**
* Sets a base path for all the generated paths
*
*<code>
* $url->setBasePath("/var/www/htdocs/");
*</code>
*/
PHP_METHOD(Phalcon_Mvc_Url, setBasePath) {
zval *basePath_param = NULL;
zval basePath;
zval *this_ptr = getThis();
ZVAL_UNDEF(&basePath);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &basePath_param);
if (UNEXPECTED(Z_TYPE_P(basePath_param) != IS_STRING && Z_TYPE_P(basePath_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'basePath' must be of the type string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(basePath_param) == IS_STRING)) {
zephir_get_strval(&basePath, basePath_param);
} else {
ZEPHIR_INIT_VAR(&basePath);
ZVAL_EMPTY_STRING(&basePath);
}
zephir_update_property_zval(this_ptr, SL("basePath"), &basePath);
RETURN_THIS();
}
/**
* Returns the prefix for all the generated urls. By default /
*/
PHP_METHOD(Phalcon_Mvc_Url, getBaseUri) {
zval *_SERVER, baseUri, phpSelf, uri, _0;
zval *this_ptr = getThis();
ZVAL_UNDEF(&baseUri);
ZVAL_UNDEF(&phpSelf);
ZVAL_UNDEF(&uri);
ZVAL_UNDEF(&_0);
ZEPHIR_MM_GROW();
zephir_get_global(&_SERVER, SL("_SERVER"));
zephir_read_property(&_0, this_ptr, SL("baseUri"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_CPY_WRT(&baseUri, &_0);
if (Z_TYPE_P(&baseUri) == IS_NULL) {
ZEPHIR_OBS_VAR(&phpSelf);
if (zephir_array_isset_string_fetch(&phpSelf, _SERVER, SL("PHP_SELF"), 0)) {
ZEPHIR_INIT_VAR(&uri);
phalcon_get_uri(&uri, &phpSelf);
} else {
ZEPHIR_INIT_NVAR(&uri);
ZVAL_NULL(&uri);
}
ZEPHIR_INIT_NVAR(&baseUri);
if (!(zephir_is_true(&uri))) {
ZVAL_STRING(&baseUri, "/");
} else {
ZEPHIR_CONCAT_SVS(&baseUri, "/", &uri, "/");
}
zephir_update_property_zval(this_ptr, SL("baseUri"), &baseUri);
}
RETURN_CCTOR(&baseUri);
}
/**
* Unsets an index in an array property
*/
int zephir_unset_property_array(zval *object, char *property, unsigned int property_length, zval *index)
{
zval tmp;
int separated = 0;
if (Z_TYPE_P(object) == IS_OBJECT) {
zephir_read_property(&tmp, object, property, property_length, PH_NOISY_CC);
Z_TRY_DELREF(tmp);
/** Separation only when refcount > 1 */
if (Z_REFCOUNTED(tmp) && Z_REFCOUNT(tmp) > 1) {
if (!Z_ISREF(tmp)) {
zval new_zv;
ZVAL_DUP(&new_zv, &tmp);
ZVAL_COPY_VALUE(&tmp, &new_zv);
Z_TRY_DELREF(new_zv);
separated = 1;
}
}
zephir_array_unset(&tmp, index, PH_SEPARATE);
if (separated) {
zephir_update_property_zval(object, property, property_length, &tmp);
}
}
return SUCCESS;
}
PHP_METHOD(PhalconPlus_Logger_Formatter_LinePlus, __construct) {
zval *formatString_param = NULL;
zval formatString;
zval *this_ptr = getThis();
ZVAL_UNDEF(&formatString);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &formatString_param);
if (UNEXPECTED(Z_TYPE_P(formatString_param) != IS_STRING && Z_TYPE_P(formatString_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'formatString' must be of the type string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(formatString_param) == IS_STRING)) {
zephir_get_strval(&formatString, formatString_param);
} else {
ZEPHIR_INIT_VAR(&formatString);
ZVAL_EMPTY_STRING(&formatString);
}
if (!(ZEPHIR_IS_EMPTY(&formatString))) {
zephir_update_property_zval(this_ptr, SL("formatString"), &formatString);
}
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Test_Oo_DynamicProp, setExistingStringPropertyString) {
zval *value_param = NULL;
zval *value = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &value_param);
if (unlikely(Z_TYPE_P(value_param) != IS_STRING && Z_TYPE_P(value_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'value' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(value_param) == IS_STRING)) {
zephir_get_strval(value, value_param);
} else {
ZEPHIR_INIT_VAR(value);
ZVAL_EMPTY_STRING(value);
}
zephir_update_property_zval(this_ptr, SL("eproperty"), value TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Test_Oo_DynamicProp, setPropertyVariableInt) {
int a = 10;
zval *property_param = NULL, *_0;
zval *property = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &property_param);
if (unlikely(Z_TYPE_P(property_param) != IS_STRING && Z_TYPE_P(property_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'property' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (unlikely(Z_TYPE_P(property_param) == IS_STRING)) {
property = property_param;
} else {
ZEPHIR_INIT_VAR(property);
ZVAL_EMPTY_STRING(property);
}
ZEPHIR_INIT_VAR(_0);
ZVAL_LONG(_0, a);
zephir_update_property_zval(this_ptr, Z_STRVAL_P(property), Z_STRLEN_P(property), _0 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Test_Oo_DynamicProp, setPropertyBoolFalse) {
zval *property_param = NULL;
zval *property = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &property_param);
if (unlikely(Z_TYPE_P(property_param) != IS_STRING && Z_TYPE_P(property_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'property' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(property_param) == IS_STRING)) {
zephir_get_strval(property, property_param);
} else {
ZEPHIR_INIT_VAR(property);
ZVAL_EMPTY_STRING(property);
}
zephir_update_property_zval(this_ptr, Z_STRVAL_P(property), Z_STRLEN_P(property), ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Test\Router\Route constructor
*
* @param string pattern
* @param array paths
* @param array|string httpMethods
*/
PHP_METHOD(Test_Router_Route, __construct) {
int ZEPHIR_LAST_CALL_STATUS;
zval *pattern, pattern_sub, *paths = NULL, paths_sub, *httpMethods = NULL, httpMethods_sub, __$null;
ZEPHIR_INIT_THIS();
ZVAL_UNDEF(&pattern_sub);
ZVAL_UNDEF(&paths_sub);
ZVAL_UNDEF(&httpMethods_sub);
ZVAL_NULL(&__$null);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 2, &pattern, &paths, &httpMethods);
if (!paths) {
paths = &paths_sub;
paths = &__$null;
}
if (!httpMethods) {
httpMethods = &httpMethods_sub;
httpMethods = &__$null;
}
ZEPHIR_CALL_METHOD(NULL, this_ptr, "reconfigure", NULL, 0, pattern, paths);
zephir_check_call_status();
zephir_update_property_zval(this_ptr, SL("_methods"), httpMethods);
ZEPHIR_MM_RESTORE();
}
/**
* @link https://github.com/phalcon/zephir/issues/915
*/
PHP_METHOD(Test_Exception, testRuntimePropertyFetch) {
zval *message_param = NULL;
zval message;
zval *this_ptr = getThis();
ZVAL_UNDEF(&message);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &message_param);
if (UNEXPECTED(Z_TYPE_P(message_param) != IS_STRING && Z_TYPE_P(message_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'message' must be of the type string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(message_param) == IS_STRING)) {
zephir_get_strval(&message, message_param);
} else {
ZEPHIR_INIT_VAR(&message);
ZVAL_EMPTY_STRING(&message);
}
zephir_update_property_zval(this_ptr, SL("message"), &message);
ZEPHIR_MM_RESTORE();
}
/**
* Destroys the session bag
*
*<code>
* $user->destroy();
*</code>
*/
PHP_METHOD(Phalcon_Session_Bag, destroy) {
zval _0, _1, _2, _3;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *this_ptr = getThis();
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1);
ZVAL_UNDEF(&_2);
ZVAL_UNDEF(&_3);
ZEPHIR_MM_GROW();
zephir_read_property(&_0, this_ptr, SL("_initialized"), PH_NOISY_CC | PH_READONLY);
if (ZEPHIR_IS_FALSE_IDENTICAL(&_0)) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "initialize", NULL, 0);
zephir_check_call_status();
}
ZEPHIR_INIT_VAR(&_1);
array_init(&_1);
zephir_update_property_zval(this_ptr, SL("_data"), &_1);
zephir_read_property(&_2, this_ptr, SL("_session"), PH_NOISY_CC | PH_READONLY);
zephir_read_property(&_3, this_ptr, SL("_name"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_CALL_METHOD(NULL, &_2, "remove", NULL, 0, &_3);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(PhalconPlus_Base_ProtoOrderBy, setProperty) {
zval *property_param = NULL;
zval property;
zval *this_ptr = getThis();
ZVAL_UNDEF(&property);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &property_param);
if (UNEXPECTED(Z_TYPE_P(property_param) != IS_STRING && Z_TYPE_P(property_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'property' must be of the type string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(property_param) == IS_STRING)) {
zephir_get_strval(&property, property_param);
} else {
ZEPHIR_INIT_VAR(&property);
ZVAL_EMPTY_STRING(&property);
}
zephir_update_property_zval(this_ptr, SL("property"), &property);
ZEPHIR_MM_RESTORE();
}
/**
* Phalcon\Logger\Formatter\Json construct
*
* @param string dateFormat
*/
PHP_METHOD(Phalcon_Logger_Formatter_Json, __construct) {
zval *dateFormat_param = NULL;
zval dateFormat;
zval *this_ptr = getThis();
ZVAL_UNDEF(&dateFormat);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &dateFormat_param);
if (!dateFormat_param) {
ZEPHIR_INIT_VAR(&dateFormat);
ZVAL_STRING(&dateFormat, "");
} else {
zephir_get_strval(&dateFormat, dateFormat_param);
}
if (!(Z_TYPE_P(&dateFormat) == IS_UNDEF) && Z_STRLEN_P(&dateFormat)) {
zephir_update_property_zval(this_ptr, SL("dateFormat"), &dateFormat);
}
ZEPHIR_MM_RESTORE();
}
/**
* Phalcon\Session\Bag constructor
*/
PHP_METHOD(Phalcon_Session_Bag, __construct) {
zval *name_param = NULL;
zval name;
zval *this_ptr = getThis();
ZVAL_UNDEF(&name);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &name_param);
if (UNEXPECTED(Z_TYPE_P(name_param) != IS_STRING && Z_TYPE_P(name_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'name' must be of the type string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(name_param) == IS_STRING)) {
zephir_get_strval(&name, name_param);
} else {
ZEPHIR_INIT_VAR(&name);
ZVAL_EMPTY_STRING(&name);
}
zephir_update_property_zval(this_ptr, SL("_name"), &name);
ZEPHIR_MM_RESTORE();
}
/**
* Checks whether obj is an object and updates zval property with another zval
*/
int zephir_update_property_zval_zval(zval *object, zval *property, zval *value)
{
if (Z_TYPE_P(property) != IS_STRING) {
php_error_docref(NULL, E_WARNING, "Property should be string");
return FAILURE;
}
return zephir_update_property_zval(object, Z_STRVAL_P(property), Z_STRLEN_P(property), value);
}
/**
* Resets internal meta-data in order to regenerate it
*
*<code>
* $metaData->reset();
*</code>
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, reset) {
zval _0, _1;
zval *this_ptr = getThis();
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1);
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(&_0);
array_init(&_0);
zephir_update_property_zval(this_ptr, SL("_metaData"), &_0);
ZEPHIR_INIT_VAR(&_1);
array_init(&_1);
zephir_update_property_zval(this_ptr, SL("_columnMap"), &_1);
ZEPHIR_MM_RESTORE();
}
/**
* Increments an object property
*/
int zephir_property_incr_decr(zval *object, char *property_name, unsigned int property_length, unsigned int increment)
{
zval tmp;
zend_class_entry *ce;
int separated = 0;
ZVAL_UNDEF(&tmp);
if (Z_TYPE_P(object) != IS_OBJECT) {
php_error_docref(NULL, E_WARNING, "Attempt to assign property of non-object");
return FAILURE;
}
ce = Z_OBJCE_P(object);
if (ce->parent) {
ce = zephir_lookup_class_ce(ce, property_name, property_length);
}
zephir_read_property(&tmp, object, property_name, property_length, 0);
if (Z_TYPE(tmp) > IS_UNDEF) {
Z_TRY_DELREF(tmp);
/** Separation only when refcount > 1 */
if (Z_REFCOUNTED(tmp)) {
if (Z_REFCOUNT(tmp) > 1) {
if (!Z_ISREF(tmp)) {
zval new_zv;
ZVAL_DUP(&new_zv, &tmp);
ZVAL_COPY_VALUE(&tmp, &new_zv);
Z_TRY_DELREF(new_zv);
separated = 1;
}
}
} else {
zval new_zv;
ZVAL_DUP(&new_zv, &tmp);
ZVAL_COPY_VALUE(&tmp, &new_zv);
Z_TRY_DELREF(new_zv);
separated = 1;
}
if (increment) {
zephir_increment(&tmp);
} else {
zephir_decrement(&tmp);
}
if (separated) {
zephir_update_property_zval(object, property_name, property_length, &tmp);
}
}
return SUCCESS;
}
/**
* Returns a cached content
*/
PHP_METHOD(Phalcon_Cache_Backend_Libmemcached, get) {
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *keyName_param = NULL, *lifetime = NULL, lifetime_sub, __$null, memcache, prefixedKey, cachedContent, _0, _1, _2;
zval keyName;
zval *this_ptr = getThis();
ZVAL_UNDEF(&keyName);
ZVAL_UNDEF(&lifetime_sub);
ZVAL_NULL(&__$null);
ZVAL_UNDEF(&memcache);
ZVAL_UNDEF(&prefixedKey);
ZVAL_UNDEF(&cachedContent);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1);
ZVAL_UNDEF(&_2);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &keyName_param, &lifetime);
zephir_get_strval(&keyName, keyName_param);
if (!lifetime) {
lifetime = &lifetime_sub;
lifetime = &__$null;
}
ZEPHIR_OBS_VAR(&memcache);
zephir_read_property(&memcache, this_ptr, SL("_memcache"), PH_NOISY_CC);
if (Z_TYPE_P(&memcache) != IS_OBJECT) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "_connect", NULL, 0);
zephir_check_call_status();
ZEPHIR_OBS_NVAR(&memcache);
zephir_read_property(&memcache, this_ptr, SL("_memcache"), PH_NOISY_CC);
}
zephir_read_property(&_0, this_ptr, SL("_prefix"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_INIT_VAR(&prefixedKey);
ZEPHIR_CONCAT_VV(&prefixedKey, &_0, &keyName);
zephir_update_property_zval(this_ptr, SL("_lastKey"), &prefixedKey);
ZEPHIR_CALL_METHOD(&cachedContent, &memcache, "get", NULL, 0, &prefixedKey);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_1, &memcache, "getresultcode", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_LONG_IDENTICAL(&_1, 16)) {
RETURN_MM_NULL();
}
if (zephir_is_numeric(&cachedContent)) {
RETURN_CCTOR(&cachedContent);
}
zephir_read_property(&_2, this_ptr, SL("_frontend"), PH_NOISY_CC | PH_READONLY);
ZEPHIR_RETURN_CALL_METHOD(&_2, "afterretrieve", NULL, 0, &cachedContent);
zephir_check_call_status();
RETURN_MM();
}
/**
* Updates an array property
*/
int zephir_update_property_array(zval *object, const char *property, zend_uint property_length, const zval *index, zval *value)
{
zval tmp;
int separated = 0;
if (Z_TYPE_P(object) == IS_OBJECT) {
zephir_read_property(&tmp, object, property, property_length, PH_NOISY | PH_READONLY);
/** Separation only when refcount > 1 */
if (Z_REFCOUNTED(tmp)) {
if (Z_REFCOUNT(tmp) > 1) {
if (!Z_ISREF(tmp)) {
zval new_zv;
ZVAL_DUP(&new_zv, &tmp);
ZVAL_COPY_VALUE(&tmp, &new_zv);
Z_TRY_DELREF(new_zv);
separated = 1;
}
}
} else {
zval new_zv;
ZVAL_DUP(&new_zv, &tmp);
ZVAL_COPY_VALUE(&tmp, &new_zv);
Z_TRY_DELREF(new_zv);
separated = 1;
}
/** Convert the value to array if not is an array */
if (Z_TYPE(tmp) != IS_ARRAY) {
if (separated) {
convert_to_array(&tmp);
} else {
array_init(&tmp);
separated = 1;
}
Z_DELREF(tmp);
}
Z_TRY_ADDREF_P(value);
if (Z_TYPE_P(index) == IS_STRING) {
zend_symtable_str_update(Z_ARRVAL(tmp), Z_STRVAL_P(index), Z_STRLEN_P(index), value);
} else if (Z_TYPE_P(index) == IS_LONG) {
zend_hash_index_update(Z_ARRVAL(tmp), Z_LVAL_P(index), value);
} else if (Z_TYPE_P(index) == IS_NULL) {
zend_hash_next_index_insert(Z_ARRVAL(tmp), value);
}
if (separated) {
zephir_update_property_zval(object, property, property_length, &tmp);
}
}
return SUCCESS;
}
/**
* Appends a zval value to an array property
*/
int zephir_update_property_array_append(zval *object, char *property, unsigned int property_length, zval *value)
{
zval tmp;
int separated = 0;
ZVAL_UNDEF(&tmp);
if (Z_TYPE_P(object) != IS_OBJECT) {
return SUCCESS;
}
zephir_read_property(&tmp, object, property, property_length, PH_NOISY_CC);
Z_TRY_DELREF(tmp);
/** Separation only when refcount > 1 */
if (Z_REFCOUNTED(tmp)) {
if (Z_REFCOUNT(tmp) > 1) {
if (!Z_ISREF(tmp)) {
zval new_zv;
ZVAL_DUP(&new_zv, &tmp);
ZVAL_COPY_VALUE(&tmp, &new_zv);
Z_TRY_DELREF(new_zv);
separated = 1;
}
}
} else {
zval new_zv;
ZVAL_DUP(&new_zv, &tmp);
ZVAL_COPY_VALUE(&tmp, &new_zv);
Z_TRY_DELREF(new_zv);
separated = 1;
}
/** Convert the value to array if not is an array */
if (Z_TYPE(tmp) != IS_ARRAY) {
if (separated) {
convert_to_array(&tmp);
} else {
array_init(&tmp);
separated = 1;
}
Z_DELREF(tmp);
}
Z_TRY_ADDREF_P(value);
add_next_index_zval(&tmp, value);
if (separated) {
zephir_update_property_zval(object, property, property_length, &tmp);
}
return SUCCESS;
}
/**
* Phalcon\Acl\Operation constructor
*/
PHP_METHOD(Phalcon_Acl_Operation, __construct) {
zval *name_param = NULL, *description_param = NULL;
zval name, description;
zval *this_ptr = getThis();
ZVAL_UNDEF(&name);
ZVAL_UNDEF(&description);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &name_param, &description_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 of the type 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 (!description_param) {
ZEPHIR_INIT_VAR(&description);
ZVAL_STRING(&description, "");
} else {
zephir_get_strval(&description, description_param);
}
if (ZEPHIR_IS_STRING(&name, "*")) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_acl_exception_ce, "Operation name cannot be '*'", "phalcon/acl/operation.zep", 40);
return;
}
zephir_update_property_zval(this_ptr, SL("name"), &name);
if (!(Z_TYPE_P(&description) == IS_UNDEF) && Z_STRLEN_P(&description)) {
zephir_update_property_zval(this_ptr, SL("description"), &description);
}
ZEPHIR_MM_RESTORE();
}
/**
* Sets if the service is shared or not
*/
PHP_METHOD(Phalcon_Di_Service, setShared) {
zval *shared_param = NULL, __$true, __$false;
zend_bool shared;
zval *this_ptr = getThis();
ZVAL_BOOL(&__$true, 1);
ZVAL_BOOL(&__$false, 0);
zephir_fetch_params(0, 1, 0, &shared_param);
shared = zephir_get_boolval(shared_param);
if (shared) {
zephir_update_property_zval(this_ptr, SL("_shared"), &__$true);
} else {
zephir_update_property_zval(this_ptr, SL("_shared"), &__$false);
}
}
PHP_METHOD(Test_Oo_DynamicProp, setNonExistingStringProperty) {
zval *_0;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "works", 1);
zephir_update_property_zval(this_ptr, SL("property"), _0 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
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);
}
