自学教程：C++ zephir_update_property_array_append函数代码示例

/** * 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, &parameters_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);}

/** * 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 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();}