/**
* Adds a resource to the ACL list
*
* Access names can be a particular action, by example
* search, update, delete, etc or a list of them
*
* Example:
* <code>
* //Add a resource to the the list allowing access to an action
* $acl->addResource(new Phalcon\Acl\Resource('customers'), 'search');
* $acl->addResource('customers', 'search');
*
* //Add a resource with an access list
* $acl->addResource(new Phalcon\Acl\Resource('customers'), array('create', 'search'));
* $acl->addResource('customers', array('create', 'search'));
* </code>
*
* @param Phalcon\Acl\Resource|string resourceValue
* @param array|string accessList
*/
PHP_METHOD(Phalcon_Acl_Adapter_Memory, addResource) {
int ZEPHIR_LAST_CALL_STATUS;
zval *resourceValue, *accessList, *resourceName = NULL, *resourceObject = NULL, *_0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &resourceValue, &accessList);
if (Z_TYPE_P(resourceValue) == IS_OBJECT) {
ZEPHIR_CALL_METHOD(&resourceName, resourceValue, "getname", NULL, 0);
zephir_check_call_status();
ZEPHIR_CPY_WRT(resourceObject, resourceValue);
} else {
ZEPHIR_CPY_WRT(resourceName, resourceValue);
ZEPHIR_INIT_NVAR(resourceObject);
object_init_ex(resourceObject, phalcon_acl_resource_ce);
ZEPHIR_CALL_METHOD(NULL, resourceObject, "__construct", NULL, 81, resourceName);
zephir_check_call_status();
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_resourcesNames"), PH_NOISY_CC);
if (!(zephir_array_isset(_0, resourceName))) {
zephir_update_property_array_append(this_ptr, SL("_resources"), resourceObject TSRMLS_CC);
zephir_update_property_array(this_ptr, SL("_resourcesNames"), resourceName, ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
}
ZEPHIR_RETURN_CALL_METHOD(this_ptr, "addresourceaccess", NULL, 0, resourceName, accessList);
zephir_check_call_status();
RETURN_MM();
}
/**
* Adds an option to the current options
*
* @param array option
* @return this
*/
PHP_METHOD(Phalcon_Forms_Element_Select, addOption) {
HashTable *_1;
HashPosition _0;
zval *option, *key = NULL, *value = NULL, **_2;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &option);
if (Z_TYPE_P(option) == IS_ARRAY) {
zephir_is_iterable(option, &_1, &_0, 0, 0, "phalcon/forms/element/select.zep", 85);
for (
; zephir_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS
; zephir_hash_move_forward_ex(_1, &_0)
) {
ZEPHIR_GET_HMKEY(key, _1, _0);
ZEPHIR_GET_HVALUE(value, _2);
zephir_update_property_array(this_ptr, SL("_optionsValues"), key, value TSRMLS_CC);
}
} else {
zephir_update_property_array_append(this_ptr, SL("_optionsValues"), option TSRMLS_CC);
}
RETURN_THIS();
}
/**
* Adds a variable to the debug output
*/
PHP_METHOD(Phalcon_Debug, debugVar) {
zval *_0;
int ZEPHIR_LAST_CALL_STATUS;
zval *key = NULL;
zval *varz, *key_param = NULL, *_1 = NULL, *_2;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &varz, &key_param);
if (!key_param) {
ZEPHIR_INIT_VAR(key);
ZVAL_EMPTY_STRING(key);
} else {
zephir_get_strval(key, key_param);
}
ZEPHIR_INIT_VAR(_0);
zephir_create_array(_0, 3, 0 TSRMLS_CC);
zephir_array_fast_append(_0, varz);
ZEPHIR_CALL_FUNCTION(&_1, "debug_backtrace", NULL, 157);
zephir_check_call_status();
zephir_array_fast_append(_0, _1);
ZEPHIR_INIT_VAR(_2);
zephir_time(_2);
zephir_array_fast_append(_0, _2);
zephir_update_property_array_append(this_ptr, SL("_data"), _0 TSRMLS_CC);
RETURN_THIS();
}
/**
* Internal function to add a handler to the group
*
* @param string|array method
* @param string routePattern
* @param mixed handler
* @param string name
*/
PHP_METHOD(Phalcon_Mvc_Micro_Collection, _addMap) {
zval *_0;
zval *method_param = NULL, *routePattern, *handler, *name;
zval *method = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 4, 0, &method_param, &routePattern, &handler, &name);
if (UNEXPECTED(Z_TYPE_P(method_param) != IS_STRING && Z_TYPE_P(method_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'method' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(method_param) == IS_STRING)) {
zephir_get_strval(method, method_param);
} else {
ZEPHIR_INIT_VAR(method);
ZVAL_EMPTY_STRING(method);
}
ZEPHIR_INIT_VAR(_0);
zephir_create_array(_0, 4, 0 TSRMLS_CC);
zephir_array_fast_append(_0, method);
zephir_array_fast_append(_0, routePattern);
zephir_array_fast_append(_0, handler);
zephir_array_fast_append(_0, name);
zephir_update_property_array_append(this_ptr, SL("_handlers"), _0 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Adds a resource to the annotations handler
* A resource is a class that contains routing annotations
* The class is located in a module
*/
PHP_METHOD(Phalcon_Mvc_Router_Annotations, addModuleResource) {
zval *_0;
zval *module_param = NULL, *handler_param = NULL, *prefix_param = NULL;
zval *module = NULL, *handler = NULL, *prefix = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 1, &module_param, &handler_param, &prefix_param);
if (unlikely(Z_TYPE_P(module_param) != IS_STRING && Z_TYPE_P(module_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'module' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(module_param) == IS_STRING)) {
zephir_get_strval(module, module_param);
} else {
ZEPHIR_INIT_VAR(module);
ZVAL_EMPTY_STRING(module);
}
if (unlikely(Z_TYPE_P(handler_param) != IS_STRING && Z_TYPE_P(handler_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'handler' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(handler_param) == IS_STRING)) {
zephir_get_strval(handler, handler_param);
} else {
ZEPHIR_INIT_VAR(handler);
ZVAL_EMPTY_STRING(handler);
}
if (!prefix_param) {
ZEPHIR_INIT_VAR(prefix);
ZVAL_EMPTY_STRING(prefix);
} else {
if (unlikely(Z_TYPE_P(prefix_param) != IS_STRING && Z_TYPE_P(prefix_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'prefix' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(prefix_param) == IS_STRING)) {
zephir_get_strval(prefix, prefix_param);
} else {
ZEPHIR_INIT_VAR(prefix);
ZVAL_EMPTY_STRING(prefix);
}
}
ZEPHIR_INIT_VAR(_0);
zephir_create_array(_0, 3, 0 TSRMLS_CC);
zephir_array_fast_append(_0, prefix);
zephir_array_fast_append(_0, handler);
zephir_array_fast_append(_0, module);
zephir_update_property_array_append(this_ptr, SL("_handlers"), _0 TSRMLS_CC);
if (0) {
zephir_update_property_this(this_ptr, SL("_processed"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
} else {
zephir_update_property_this(this_ptr, SL("_processed"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
}
RETURN_THIS();
}
/**
* Adds a filter to current list of filters
*/
PHP_METHOD(Phalcon_Forms_Element, addFilter) {
zval *_0$$5, *_1$$6;
zval *filter_param = NULL, *filters = NULL;
zval *filter = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &filter_param);
zephir_get_strval(filter, filter_param);
filters = zephir_fetch_nproperty_this(this_ptr, SL("_filters"), PH_NOISY_CC);
if (Z_TYPE_P(filters) == IS_ARRAY) {
zephir_update_property_array_append(this_ptr, SL("_filters"), filter TSRMLS_CC);
} else {
if (Z_TYPE_P(filters) == IS_STRING) {
ZEPHIR_INIT_VAR(_0$$5);
zephir_create_array(_0$$5, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_0$$5, filters);
zephir_array_fast_append(_0$$5, filter);
zephir_update_property_this(this_ptr, SL("_filters"), _0$$5 TSRMLS_CC);
} else {
ZEPHIR_INIT_VAR(_1$$6);
zephir_create_array(_1$$6, 1, 0 TSRMLS_CC);
zephir_array_fast_append(_1$$6, filter);
zephir_update_property_this(this_ptr, SL("_filters"), _1$$6 TSRMLS_CC);
}
}
RETURN_THIS();
}
/**
* Adds a route to the router
*
*<code>
* $router->add('/about', 'About::main');
*</code>
*
* @param string pattern
* @param string/array paths
* @return Phalcon\Cli\Router\Route
*/
PHP_METHOD(Phalcon_Cli_Router, add) {
int ZEPHIR_LAST_CALL_STATUS;
zval *pattern_param = NULL, *paths = NULL, *route;
zval *pattern = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &pattern_param, &paths);
if (unlikely(Z_TYPE_P(pattern_param) != IS_STRING && Z_TYPE_P(pattern_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'pattern' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(pattern_param) == IS_STRING)) {
zephir_get_strval(pattern, pattern_param);
} else {
ZEPHIR_INIT_VAR(pattern);
ZVAL_EMPTY_STRING(pattern);
}
if (!paths) {
paths = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_INIT_VAR(route);
object_init_ex(route, phalcon_cli_router_route_ce);
ZEPHIR_CALL_METHOD(NULL, route, "__construct", NULL, 123, pattern, paths);
zephir_check_call_status();
zephir_update_property_array_append(this_ptr, SL("_routes"), route TSRMLS_CC);
RETURN_CCTOR(route);
}
/**
* Adds a route applying the common attributes
*/
PHP_METHOD(Phalcon_Mvc_Router_Group, _addRoute) {
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_0 = NULL;
zval *pattern_param = NULL, *paths = NULL, *httpMethods = NULL, *mergedPaths = NULL, *route, *defaultPaths, *processedPaths = NULL, *_1, *_2;
zval *pattern = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 2, &pattern_param, &paths, &httpMethods);
if (unlikely(Z_TYPE_P(pattern_param) != IS_STRING && Z_TYPE_P(pattern_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'pattern' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(pattern_param) == IS_STRING)) {
zephir_get_strval(pattern, pattern_param);
} else {
ZEPHIR_INIT_VAR(pattern);
ZVAL_EMPTY_STRING(pattern);
}
if (!paths) {
paths = ZEPHIR_GLOBAL(global_null);
}
if (!httpMethods) {
httpMethods = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_OBS_VAR(defaultPaths);
zephir_read_property_this(&defaultPaths, this_ptr, SL("_paths"), PH_NOISY_CC);
if (Z_TYPE_P(defaultPaths) == IS_ARRAY) {
if (Z_TYPE_P(paths) == IS_STRING) {
ZEPHIR_CALL_CE_STATIC(&processedPaths, phalcon_mvc_router_route_ce, "getroutepaths", &_0, 77, paths);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(processedPaths, paths);
}
if (Z_TYPE_P(processedPaths) == IS_ARRAY) {
ZEPHIR_INIT_VAR(mergedPaths);
zephir_fast_array_merge(mergedPaths, &(defaultPaths), &(processedPaths) TSRMLS_CC);
} else {
ZEPHIR_CPY_WRT(mergedPaths, defaultPaths);
}
} else {
ZEPHIR_CPY_WRT(mergedPaths, paths);
}
ZEPHIR_INIT_VAR(route);
object_init_ex(route, phalcon_mvc_router_route_ce);
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_2);
ZEPHIR_CONCAT_VV(_2, _1, pattern);
ZEPHIR_CALL_METHOD(NULL, route, "__construct", NULL, 76, _2, mergedPaths, httpMethods);
zephir_check_call_status();
zephir_update_property_array_append(this_ptr, SL("_routes"), route TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, route, "setgroup", NULL, 361, this_ptr);
zephir_check_call_status();
RETURN_CCTOR(route);
}
/**
* Stops the active profile
*/
PHP_METHOD(Phalcon_Db_Profiler, stopProfile) {
zval *finalTime = NULL, *initialTime = NULL, *activeProfile = NULL, *_0, *_1, *_2;
zend_long ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(finalTime);
zephir_microtime(finalTime, ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_activeProfile"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(activeProfile, _0);
ZEPHIR_CALL_METHOD(NULL, activeProfile, "setfinaltime", NULL, 0, finalTime);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&initialTime, activeProfile, "getinitialtime", NULL, 0);
zephir_check_call_status();
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_totalSeconds"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(_1);
zephir_sub_function(_1, finalTime, initialTime);
ZEPHIR_INIT_VAR(_2);
zephir_add_function(_2, _0, _1);
zephir_update_property_this(getThis(), SL("_totalSeconds"), _2 TSRMLS_CC);
zephir_update_property_array_append(this_ptr, SL("_allProfiles"), activeProfile TSRMLS_CC);
if ((zephir_method_exists_ex(this_ptr, SS("afterendprofile") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "afterendprofile", NULL, 0, activeProfile);
zephir_check_call_status();
}
RETURN_THIS();
}
/**
* Adds a inline javascript to the collection
*/
PHP_METHOD(Phalcon_Assets_Collection, addInlineJs) {
int ZEPHIR_LAST_CALL_STATUS;
zend_bool filter;
zval *content_param = NULL, *filter_param = NULL, *attributes = NULL, *collectionAttributes = NULL, *_0;
zval *content = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 2, &content_param, &filter_param, &attributes);
zephir_get_strval(content, content_param);
if (!filter_param) {
filter = 1;
} else {
filter = zephir_get_boolval(filter_param);
}
if (!attributes) {
attributes = ZEPHIR_GLOBAL(global_null);
}
if (Z_TYPE_P(attributes) == IS_ARRAY) {
ZEPHIR_CPY_WRT(collectionAttributes, attributes);
} else {
ZEPHIR_OBS_NVAR(collectionAttributes);
zephir_read_property_this(&collectionAttributes, this_ptr, SL("_attributes"), PH_NOISY_CC);
}
ZEPHIR_INIT_VAR(_0);
object_init_ex(_0, phalcon_assets_inline_js_ce);
ZEPHIR_CALL_METHOD(NULL, _0, "__construct", NULL, 95, content, (filter ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false)), collectionAttributes);
zephir_check_call_status();
zephir_update_property_array_append(this_ptr, SL("_codes"), _0 TSRMLS_CC);
RETURN_THIS();
}
/**
* Imports items into the set
*
* @param mixed data
*/
PHP_METHOD(Xpl_Collection_Set, addAll) {
HashTable *_3;
HashPosition _2;
int ZEPHIR_LAST_CALL_STATUS;
zephir_fcall_cache_entry *_1 = NULL, *_7 = NULL;
zval *data, *value = NULL, *_0 = NULL, **_4, *_5$$3, *_6$$3 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &data);
ZEPHIR_CALL_CE_STATIC(&_0, xpl_type_ce, "toarray", &_1, 66, data);
zephir_check_call_status();
zephir_is_iterable(_0, &_3, &_2, 0, 0, "xpl/collection/set.zep", 119);
for (
; zephir_hash_get_current_data_ex(_3, (void**) &_4, &_2) == SUCCESS
; zephir_hash_move_forward_ex(_3, &_2)
) {
ZEPHIR_GET_HVALUE(value, _4);
_5$$3 = zephir_fetch_nproperty_this(this_ptr, SL("items"), PH_NOISY_CC);
ZEPHIR_CALL_FUNCTION(&_6$$3, "in_array", &_7, 2, value, _5$$3, ZEPHIR_GLOBAL(global_true));
zephir_check_call_status();
if (!(zephir_is_true(_6$$3))) {
zephir_update_property_array_append(this_ptr, SL("items"), value TSRMLS_CC);
}
}
ZEPHIR_MM_RESTORE();
}
/**
* Adds a javascript resource to the collection
*
* @param string path
* @param boolean local
* @param boolean filter
* @param array attributes
* @return \Phalcon\Assets\Collection
*/
PHP_METHOD(Phalcon_Assets_Collection, addJs) {
int ZEPHIR_LAST_CALL_STATUS;
zend_bool filter;
zval *path_param = NULL, *local = NULL, *filter_param = NULL, *attributes = NULL, *collectionLocal = NULL, *collectionAttributes = NULL, *_0, *_1;
zval *path = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 3, &path_param, &local, &filter_param, &attributes);
if (unlikely(Z_TYPE_P(path_param) != IS_STRING && Z_TYPE_P(path_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'path' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(path_param) == IS_STRING)) {
zephir_get_strval(path, path_param);
} else {
ZEPHIR_INIT_VAR(path);
ZVAL_EMPTY_STRING(path);
}
if (!local) {
local = ZEPHIR_GLOBAL(global_null);
}
if (!filter_param) {
filter = 1;
} else {
filter = zephir_get_boolval(filter_param);
}
if (!attributes) {
attributes = ZEPHIR_GLOBAL(global_null);
}
if (Z_TYPE_P(local) == IS_BOOL) {
ZEPHIR_CPY_WRT(collectionLocal, local);
} else {
ZEPHIR_OBS_NVAR(collectionLocal);
zephir_read_property_this(&collectionLocal, this_ptr, SL("_local"), PH_NOISY_CC);
}
if (Z_TYPE_P(attributes) == IS_ARRAY) {
ZEPHIR_CPY_WRT(collectionAttributes, attributes);
} else {
ZEPHIR_OBS_NVAR(collectionAttributes);
zephir_read_property_this(&collectionAttributes, this_ptr, SL("_attributes"), PH_NOISY_CC);
}
ZEPHIR_INIT_VAR(_0);
object_init_ex(_0, phalcon_assets_resource_js_ce);
ZEPHIR_INIT_VAR(_1);
if (filter) {
ZVAL_BOOL(_1, 1);
} else {
ZVAL_BOOL(_1, 0);
}
ZEPHIR_CALL_METHOD(NULL, _0, "__construct", NULL, 102, path, collectionLocal, _1, collectionAttributes);
zephir_check_call_status();
zephir_update_property_array_append(this_ptr, SL("_resources"), _0 TSRMLS_CC);
RETURN_THIS();
}
/**
* Adds a validator to a field
*/
PHP_METHOD(Phalcon_Validation, add) {
HashTable *_2$$5;
HashPosition _1$$5;
zval *_0$$4, *_4$$6 = NULL, *_5$$7;
zval *field, *validator, *singleField = NULL, **_3$$5;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &field, &validator);
if (Z_TYPE_P(field) == IS_ARRAY) {
if (zephir_instance_of_ev(validator, phalcon_validation_combinedfieldsvalidator_ce TSRMLS_CC)) {
ZEPHIR_INIT_VAR(_0$$4);
zephir_create_array(_0$$4, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_0$$4, field);
zephir_array_fast_append(_0$$4, validator);
zephir_update_property_array_append(this_ptr, SL("_combinedFieldsValidators"), _0$$4 TSRMLS_CC);
} else {
zephir_is_iterable(field, &_2$$5, &_1$$5, 0, 0, "phalcon/validation.zep", 215);
for (
; zend_hash_get_current_data_ex(_2$$5, (void**) &_3$$5, &_1$$5) == SUCCESS
; zend_hash_move_forward_ex(_2$$5, &_1$$5)
) {
ZEPHIR_GET_HVALUE(singleField, _3$$5);
ZEPHIR_INIT_NVAR(_4$$6);
zephir_create_array(_4$$6, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_4$$6, singleField);
zephir_array_fast_append(_4$$6, validator);
zephir_update_property_array_append(this_ptr, SL("_validators"), _4$$6 TSRMLS_CC);
}
}
} else if (Z_TYPE_P(field) == IS_STRING) {
ZEPHIR_INIT_VAR(_5$$7);
zephir_create_array(_5$$7, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_5$$7, field);
zephir_array_fast_append(_5$$7, validator);
zephir_update_property_array_append(this_ptr, SL("_validators"), _5$$7 TSRMLS_CC);
} else {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Field must be passed as array of fields or string", "phalcon/validation.zep", 221);
return;
}
RETURN_THIS();
}
/**
* Adds a route to the router without any HTTP constraint
*
*<code>
* use Phalcon\Mvc\Router;
*
* $router->add('/about', 'About::index');
* $router->add('/about', 'About::index', ['GET', 'POST']);
* $router->add('/about', 'About::index', ['GET', 'POST'], Router::POSITION_FIRST);
*</code>
*/
PHP_METHOD(Phalcon_Mvc_Router, add) {
zval *_1$$4;
int ZEPHIR_LAST_CALL_STATUS;
zval *pattern_param = NULL, *paths = NULL, *httpMethods = NULL, *position = NULL, *route = NULL, *_0$$4, *_2$$4;
zval *pattern = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 3, &pattern_param, &paths, &httpMethods, &position);
if (unlikely(Z_TYPE_P(pattern_param) != IS_STRING && Z_TYPE_P(pattern_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'pattern' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(pattern_param) == IS_STRING)) {
zephir_get_strval(pattern, pattern_param);
} else {
ZEPHIR_INIT_VAR(pattern);
ZVAL_EMPTY_STRING(pattern);
}
if (!paths) {
paths = ZEPHIR_GLOBAL(global_null);
}
if (!httpMethods) {
httpMethods = ZEPHIR_GLOBAL(global_null);
}
if (!position) {
ZEPHIR_INIT_VAR(position);
ZVAL_LONG(position, 1);
}
ZEPHIR_INIT_VAR(route);
object_init_ex(route, phalcon_mvc_router_route_ce);
ZEPHIR_CALL_METHOD(NULL, route, "__construct", NULL, 78, pattern, paths, httpMethods);
zephir_check_call_status();
do {
if (ZEPHIR_IS_LONG(position, 1)) {
zephir_update_property_array_append(this_ptr, SL("_routes"), route TSRMLS_CC);
break;
}
if (ZEPHIR_IS_LONG(position, 0)) {
ZEPHIR_INIT_VAR(_0$$4);
ZEPHIR_INIT_VAR(_1$$4);
zephir_create_array(_1$$4, 1, 0 TSRMLS_CC);
zephir_array_fast_append(_1$$4, route);
_2$$4 = zephir_fetch_nproperty_this(this_ptr, SL("_routes"), PH_NOISY_CC);
zephir_fast_array_merge(_0$$4, &(_1$$4), &(_2$$4) TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_routes"), _0$$4 TSRMLS_CC);
break;
}
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_router_exception_ce, "Invalid route position", "phalcon/mvc/router.zep", 683);
return;
} while(0);
RETURN_CCTOR(route);
}
/**
* Create/Returns a new transaction or an existing one
*/
PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, getOrCreateTransaction) {
zephir_nts_static zephir_fcall_cache_entry *_6 = NULL, *_7 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
HashTable *_2;
HashPosition _1;
zval *autoBegin_param = NULL, *dependencyInjector = NULL, *transaction = NULL, *transactions, *_0, **_3, *_4 = NULL, *_5;
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("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(dependencyInjector, _0);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_transaction_exception_ce, "A dependency injector container is required to obtain the services related to the ORM", "phalcon/mvc/model/transaction/manager.zep", 186);
return;
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_number"), PH_NOISY_CC);
if (zephir_is_true(_0)) {
ZEPHIR_OBS_VAR(transactions);
zephir_read_property_this(&transactions, this_ptr, SL("_transactions"), PH_NOISY_CC);
if (Z_TYPE_P(transactions) == IS_ARRAY) {
zephir_is_iterable(transactions, &_2, &_1, 0, 1, "phalcon/mvc/model/transaction/manager.zep", 198);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_backwards_ex(_2, &_1)
) {
ZEPHIR_GET_HVALUE(transaction, _3);
if (Z_TYPE_P(transaction) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_4);
ZVAL_BOOL(_4, 0);
ZEPHIR_CALL_METHOD(NULL, transaction, "setisnewtransaction", NULL, _4);
zephir_check_call_status();
RETURN_CCTOR(transaction);
}
}
}
}
ZEPHIR_INIT_VAR(transaction);
object_init_ex(transaction, phalcon_mvc_model_transaction_ce);
_5 = zephir_fetch_nproperty_this(this_ptr, SL("_service"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, transaction, "__construct", &_6, dependencyInjector, (autoBegin ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false)), _5);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, transaction, "settransactionmanager", &_7, this_ptr);
zephir_check_call_status();
zephir_update_property_array_append(this_ptr, SL("_transactions"), transaction TSRMLS_CC);
RETURN_ON_FAILURE(zephir_property_incr(this_ptr, SL("_number") TSRMLS_CC));
RETURN_CCTOR(transaction);
}
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();
}
/**
* Pushes a logger to the logger tail
*
* @param Phalcon\Logger\AdapterInterface logger
*/
PHP_METHOD(Phalcon_Logger_Multiple, push) {
zval *logger;
zephir_fetch_params(0, 1, 0, &logger);
zephir_update_property_array_append(this_ptr, SL("_loggers"), logger TSRMLS_CC);
}
/**
* {@inheritDoc}
*/
PHP_METHOD(Owl_Std_Collection_ArrayCollection, add) {
zval *element;
zephir_fetch_params(0, 1, 0, &element);
zephir_update_property_array_append(this_ptr, SL("elements"), element TSRMLS_CC);
}
PHP_METHOD(Owl_Router_Router, addRoute) {
zval *route;
zephir_fetch_params(0, 1, 0, &route);
zephir_update_property_array_append(this_ptr, SL("routers"), route TSRMLS_CC);
}
/**
* Appends a message to the group
*
*<code>
* $messages->appendMessage(
* new \Phalcon\Validation\Message("This is a message")
* );
*</code>
*/
PHP_METHOD(Phalcon_Validation_Message_Group, appendMessage) {
zval *message;
zephir_fetch_params(0, 1, 0, &message);
zephir_update_property_array_append(this_ptr, SL("_messages"), message TSRMLS_CC);
}
/**
* Adds a backend
*/
PHP_METHOD(Phalcon_Cache_Multiple, push) {
zval *backend;
zephir_fetch_params(0, 1, 0, &backend);
zephir_update_property_array_append(this_ptr, SL("_backends"), backend TSRMLS_CC);
RETURN_THISW();
}
/**
* Adds a filter to the collection
*/
PHP_METHOD(Phalcon_Assets_Collection, addFilter) {
zval *filter;
zephir_fetch_params(0, 1, 0, &filter);
zephir_update_property_array_append(this_ptr, SL("_filters"), filter TSRMLS_CC);
RETURN_THISW();
}
/**
* Adds a resource to the collection
*/
PHP_METHOD(Phalcon_Assets_Collection, add) {
zval *resource;
zephir_fetch_params(0, 1, 0, &resource);
zephir_update_property_array_append(this_ptr, SL("_resources"), resource TSRMLS_CC);
RETURN_THISW();
}
/**
* Adds a validator to the element
*/
PHP_METHOD(Phalcon_Forms_Element, addValidator) {
zval *validator;
zephir_fetch_params(0, 1, 0, &validator);
zephir_update_property_array_append(this_ptr, SL("_validators"), validator TSRMLS_CC);
RETURN_THISW();
}
/**
* Adds a inline code to the collection
*/
PHP_METHOD(Phalcon_Assets_Collection, addInline) {
zval *code;
zephir_fetch_params(0, 1, 0, &code);
zephir_update_property_array_append(this_ptr, SL("_codes"), code TSRMLS_CC);
RETURN_THISW();
}
/**
* Adds an option to the current options
*
* @param array option
* @return this
*/
PHP_METHOD(Phalcon_Forms_Element_Select, addOption) {
zval *option;
zephir_fetch_params(0, 1, 0, &option);
zephir_update_property_array_append(this_ptr, SL("_optionsValues"), option TSRMLS_CC);
RETURN_THISW();
}
/**
* 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);
}
/**
* Appends a message to the validator
*
* @param string message
* @param string|array field
* @param string type
*/
PHP_METHOD(Phalcon_Mvc_Model_Validator, appendMessage) {
int ZEPHIR_LAST_CALL_STATUS;
zval *message_param = NULL, *field = NULL, *type = NULL, *_0 = NULL, _1, _2;
zval *message = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 2, &message_param, &field, &type);
if (unlikely(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 a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(message_param) == IS_STRING)) {
zephir_get_strval(message, message_param);
} else {
ZEPHIR_INIT_VAR(message);
ZVAL_EMPTY_STRING(message);
}
if (!field) {
field = ZEPHIR_GLOBAL(global_null);
}
if (!type) {
ZEPHIR_CPY_WRT(type, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(type);
}
if (!(zephir_is_true(type))) {
ZEPHIR_INIT_VAR(_0);
zephir_get_class(_0, this_ptr, 0 TSRMLS_CC);
ZEPHIR_SINIT_VAR(_1);
ZVAL_STRING(&_1, "Validator", 0);
ZEPHIR_SINIT_VAR(_2);
ZVAL_STRING(&_2, "", 0);
ZEPHIR_INIT_NVAR(type);
zephir_fast_str_replace(&type, &_1, &_2, _0 TSRMLS_CC);
}
ZEPHIR_INIT_NVAR(_0);
object_init_ex(_0, phalcon_mvc_model_message_ce);
ZEPHIR_CALL_METHOD(NULL, _0, "__construct", NULL, 296, message, field, type);
zephir_check_call_status();
zephir_update_property_array_append(this_ptr, SL("_messages"), _0 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Adds a resource to the annotations handler
* A resource is a class that contains routing annotations
*/
PHP_METHOD(Phalcon_Mvc_Router_Annotations, addResource) {
zval *_0;
zval *handler_param = NULL, *prefix_param = NULL;
zval *handler = NULL, *prefix = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &handler_param, &prefix_param);
if (UNEXPECTED(Z_TYPE_P(handler_param) != IS_STRING && Z_TYPE_P(handler_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'handler' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(handler_param) == IS_STRING)) {
zephir_get_strval(handler, handler_param);
} else {
ZEPHIR_INIT_VAR(handler);
ZVAL_EMPTY_STRING(handler);
}
if (!prefix_param) {
ZEPHIR_INIT_VAR(prefix);
ZVAL_EMPTY_STRING(prefix);
} else {
if (UNEXPECTED(Z_TYPE_P(prefix_param) != IS_STRING && Z_TYPE_P(prefix_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'prefix' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(prefix_param) == IS_STRING)) {
zephir_get_strval(prefix, prefix_param);
} else {
ZEPHIR_INIT_VAR(prefix);
ZVAL_EMPTY_STRING(prefix);
}
}
ZEPHIR_INIT_VAR(_0);
zephir_create_array(_0, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_0, prefix);
zephir_array_fast_append(_0, handler);
zephir_update_property_array_append(this_ptr, SL("_handlers"), _0 TSRMLS_CC);
RETURN_THIS();
}
/**
* Adds the validators to a field
*/
PHP_METHOD(Phalcon_Validation, rules) {
HashTable *_1;
HashPosition _0;
zval *validators = NULL, *_3 = NULL;
zval *field_param = NULL, *validators_param = NULL, *validator = NULL, **_2;
zval *field = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &field_param, &validators_param);
if (unlikely(Z_TYPE_P(field_param) != IS_STRING && Z_TYPE_P(field_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'field' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(field_param) == IS_STRING)) {
zephir_get_strval(field, field_param);
} else {
ZEPHIR_INIT_VAR(field);
ZVAL_EMPTY_STRING(field);
}
validators = validators_param;
zephir_is_iterable(validators, &_1, &_0, 0, 0, "phalcon/validation.zep", 175);
for (
; zephir_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS
; zephir_hash_move_forward_ex(_1, &_0)
) {
ZEPHIR_GET_HVALUE(validator, _2);
if (zephir_instance_of_ev(validator, phalcon_validation_validatorinterface_ce TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_3);
zephir_create_array(_3, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_3, field);
zephir_array_fast_append(_3, validator);
zephir_update_property_array_append(this_ptr, SL("_validators"), _3 TSRMLS_CC);
}
}
RETURN_THIS();
}
